This is an archive of the discontinued LLVM Phabricator instance.

Differential D111265

[libc++] Add an option to disable wide character support in libc++
ClosedPublic

Authored by ldionne on Oct 6 2021, 1:20 PM.

Details

Reviewers
None
Group Reviewers
Restricted Project
Commits
rGf4c1258d5633: [libc++] Add an option to disable wide character support in libc++
Summary

Some embedded platforms do not wish to support the C library functionality
for handling wchar_t because they have no use for it. It makes sense for
libc++ to work properly on those platforms, so this commit adds a carve-out
of functionality for wchar_t.

Unfortunately, unlike some other carve-outs (e.g. random device), this
patch touches several parts of the library. However, despite the wide
impact of this patch, I still think it is important to support this
configuration since it makes it much simpler to port libc++ to some
embedded platforms.

Diff Detail

Event Timeline

ldionne created this revision.Oct 6 2021, 1:20 PM
Herald added subscribers: arichardson, mgorny. · View Herald TranscriptOct 6 2021, 1:20 PM
ldionne requested review of this revision.Oct 6 2021, 1:20 PM
Herald added a project: Restricted Project. · View Herald TranscriptOct 6 2021, 1:20 PM
Herald added a reviewer: Restricted Project. · View Herald Transcript
Herald added a subscriber: libcxx-commits. · View Herald Transcript
ldionne added a comment.Oct 6 2021, 1:23 PM

This is a monstruous diff, but fortunately it's pretty mechanical.

ldionne added a comment.Oct 6 2021, 1:26 PM

Calling out the only two things that are tricky in this patch IMO. If someone's willing to take a look at this patch, it would be great.

libcxx/include/__mbstate_t.h
2

I'm calling out attention on this file since I'm not really satisfied by the solution, but don't know how to make it better. Suggestions welcome.

This patch was developed on macOS so obviously some of this might not fly out-of-the-box on Linux, but we should find a way to make it work on all platforms, all the time.

libcxx/src/locale.cpp
4552

Calling this out too, I'm not entirely sure how to handle this properly when wchar_t isn't supported.

kubamracek added a subscriber: kubamracek.Oct 6 2021, 3:37 PM
Harbormaster completed remote builds in B127380: Diff 377661.Oct 6 2021, 5:07 PM
ldionne updated this revision to Diff 378261.Oct 8 2021, 8:58 AM

Rebase onto main.

We'll want to land this fairly quickly because of the size of the patch, which lends itself nicely
to bit rotting.

Harbormaster completed remote builds in B127799: Diff 378261.Oct 8 2021, 9:55 AM
ldionne updated this revision to Diff 378295.Oct 8 2021, 10:29 AM

Fix some failures.

Mordante added a subscriber: Mordante.Oct 8 2021, 10:51 AM

I agree we should try to land this as quickly as possible, this patch seems a huge effort!
I mainly looked at the buildsystem related, format related and locale files. I mostly ignored the tests; I expect Buildkite to help there.

I didn't see any huge issues.

libcxx/CMakeLists.txt
123

Can you add this option to docs/BuildingLibcxx.rst?

Is this feature worth mentioning in the release notes?

libcxx/include/__format/formatter_bool.h
94

Can you modify formatter_char.h in this directory and disable formatter<char, wchar_t> and formatter<wchar_t, wchar_t>?

libcxx/include/regex
1073

I'm not fond of formatting changes in this patch. I would strongly recommend to just commit the format changes now so this patch looks cleaner.

Mordante added a comment.Oct 8 2021, 11:15 AM

Somehow two of my comments weren't submitted and were lost. So here they are again.

libcxx/src/locale.cpp
4573

I we should return false instead of reaching _LIBCPP_UNREACHABLE();.

When I understand the code correctly this is only an issue when the supplied "string" contains more than one character. This basically means numpunct's decimal_point or thousands_sep isn't a single character. I think it would suffice when adding this return and handle the returned false in the callers.

When vendors report that this doesn't work properly we can discuss with them what a better solution would be, for example using a lookup table to translate their "string" to a char. For now that seems over engineering.

4667–4668

I think we should validate the return value here and two lines below.
Something like done in moneypunct_byname<char, false>

if (!checked_string_to_char_convert(__decimal_point_,
                                    lc->mon_decimal_point,
                                    loc.get()))
  __decimal_point_ = base::do_decimal_point();
Harbormaster completed remote builds in B127823: Diff 378295.Oct 8 2021, 12:45 PM
ldionne updated this revision to Diff 378349.Oct 8 2021, 1:56 PM
ldionne marked 5 inline comments as done.

Address review comments. This should still fail on Linux, I'll address that next week.

libcxx/CMakeLists.txt
123

Did both, good suggestions!

As a self note, I don't really like the duplication of information between the CMake file and the Sphinx documentation for build options. They are often out-of-sync and not everything is everywhere. But I just wanted to raise awareness about the situation -- this isn't the right place to fix it.

libcxx/include/regex
1073

You're right, sorry this slipped through. It should be one of the only places where there are such changes, and I'll avoid touching the formatting at all.

libcxx/src/locale.cpp
4667–4668

Thanks, honestly <locale> is gibberish to me.

Harbormaster completed remote builds in B127864: Diff 378349.Oct 8 2021, 3:46 PM
Mordante added a child revision: D111492: [libc++] DO NOT REVIEW FOR TESTING ONLY.Oct 9 2021, 7:35 AM
Mordante added inline comments.Oct 9 2021, 7:41 AM
libcxx/CMakeLists.txt
123

I agree I think we mentioned this duplication issue before.

libcxx/include/__mbstate_t.h
31

This fixes this compilation error on my system.

libcxx/include/locale
218

After fixing mbstate_t this header give me issues.
Commenting out a set of functions fixed my build issues.
For your convenience I created D111492 with my local modifications which is building here
https://buildkite.com/llvm-project/libcxx-ci/builds/5848

Mordante mentioned this in D111492: [libc++] DO NOT REVIEW FOR TESTING ONLY.Oct 9 2021, 9:25 AM
ldionne updated this revision to Diff 378735.Oct 11 2021, 10:51 AM
ldionne marked 2 inline comments as done.

Address CI failures (hopefully).

libcxx/include/locale
218

Yup thanks, I fixed it locally.

Harbormaster completed remote builds in B128158: Diff 378735.Oct 11 2021, 1:51 PM
ldionne accepted this revision as: Restricted Project.Oct 12 2021, 2:45 AM

I'm going to ship this now since this is a giant patch and I want to reduce the likelihood of conflicts with other patches. If there are additional comments, I'll fix them post-commit.

This revision was not accepted when it landed; it landed in state Needs Review.Oct 12 2021, 3:08 AM
Closed by commit rGf4c1258d5633: [libc++] Add an option to disable wide character support in libc++ (authored by ldionne). · Explain Why
This revision was automatically updated to reflect the committed changes.
ldionne added a commit: rGf4c1258d5633: [libc++] Add an option to disable wide character support in libc++.
thakis added a subscriber: thakis.Oct 13 2021, 10:01 AM

This is a cool feature!

I showed it to someone (not at work) and they provided the following feedback (see comment on wchar.h). I think it's a good point so I'm forwarding it, but up to you what to do with it.

libcxx/include/wchar.h
113

"""
I know it's not my job to judge, but these lines might lead to unnecessary problems:
I assume there's quite a few build scripts that look at this and say, "hey, I've got wchar.h, why not include it"
... this is not just an assumption. libc++ does the same thing with locale.h and ncurses's c++ example files greedily include it if they find it
"""

• Quuxplusone added a subscriber: • Quuxplusone.Oct 13 2021, 10:15 AM
• Quuxplusone added inline comments.
libcxx/include/wchar.h
113

+1 in that this is also inconsistent with how we treat #include <ranges> in pre-C++20 modes, and so on. For better or worse, the precedent is pretty consistently "when a header isn't supported, including it should be a no-op."

Mordante added inline comments.Oct 13 2021, 10:33 AM
libcxx/include/wchar.h
113

I know we discussed this for the incomplete ranges and format header and decided not to do an error.

However there are more CMake options that turn including a specific header in an error. For example when disabling _LIBCPP_HAS_NO_LOCALIZATION including locale.h will result in an error. I don't have a strong opinion on whether or not we should remove the #error in wchar.h, but if we remove it I think we should evaluate the other #errors in libc++.

michaelplatings mentioned this in D134938: Use builtins in <math.h>.Sep 29 2022, 10:54 PM

Large Diff

This large diff affects 608 files. Files without inline comments have been collapsed. Expand All Files

Revision Contents

PathSize
libcxx/
7 lines
cmake/
caches/
1 line
docs/
9 lines
4 lines
include/
1 line
__algorithm/
4 lines
10 lines
1 line
__format/
5 lines
2 lines
2 lines
3 lines
__functional/
2 lines
16 lines
40 lines
8 lines
__utility/
11 lines
4 lines
6 lines
2 lines
experimental/
4 lines
2 lines
4 lines
31 lines
38 lines
9 lines
2 lines
40 lines
1 line
2 lines
56 lines
21 lines
6 lines
4 lines
4 lines
src/
4 lines
11 lines
35 lines
248 lines
44 lines
test/
libcxx/
atomics/
atomics.align/
2 lines
depr/
depr.c.headers/
6 lines
16 lines
6 lines
input.output/
filesystems/
class.path/
path.member/
path.native.obs/
4 lines
path.req/
2 lines
iostream.format/
input.streams/
2 lines
output.streams/
2 lines
string.streams/
2 lines
iterators/
2 lines
2 lines
iterator.requirements/
iterator.concepts/
4 lines
localization/
locales/
locale.convenience/
conversions/
conversions.string/
2 lines
16 lines
16 lines
strings/
c.strings/
2 lines
2 lines
type_traits/
2 lines
utilities/
format/
format.arguments/
format.arg/
2 lines
format.args/
2 lines
format.string/
format.string.std/
4 lines
4 lines
4 lines
4 lines
2 lines
2 lines
libcxx/
diagnostics/
detail.headers/
std/
re/
re.syn/
17 lines
std/
atomics/
atomics.types.generic/
4 lines
2 lines
2 lines
concepts/
concepts.lang/
concept.default.init/
4 lines
depr/
depr.c.headers/
7 lines
2 lines
2 lines
experimental/
iterator/
ostream.joiner/
ostream.joiner.cons/
17 lines
ostream.joiner.ops/
5 lines
4 lines
4 lines
4 lines
memory/
memory.resource.aliases/
4 lines
4 lines
input.output/
file.streams/
c.files/
2 lines
fstreams/
filebuf.assign/
3 lines
3 lines
3 lines
filebuf.cons/
2 lines
3 lines
filebuf.members/
5 lines
5 lines
filebuf.virtuals/
3 lines
3 lines
2 lines
fstream.assign/
3 lines
3 lines
3 lines
fstream.cons/
2 lines
3 lines
3 lines
3 lines
3 lines
fstream.members/
3 lines
3 lines
3 lines
3 lines
3 lines
ifstream.assign/
2 lines
2 lines
2 lines
ifstream.cons/
2 lines
2 lines
3 lines
3 lines
3 lines
ifstream.members/
2 lines
2 lines
2 lines
2 lines
2 lines
ofstream.assign/
3 lines
3 lines
3 lines
ofstream.cons/
2 lines
3 lines
3 lines
3 lines
3 lines
ofstream.members/
3 lines
3 lines
3 lines
3 lines
3 lines
filesystems/
class.path/
path.member/
4 lines
path.assign/
2 lines
44 lines
6 lines
path.construct/
2 lines
path.generic.obs/
2 lines
2 lines
path.native.obs/
2 lines
path.nonmember/
6 lines
iostream.format/
ext.manip/
2 lines
2 lines
2 lines
2 lines
input.streams/
iostreamclass/
iostream.assign/
2 lines
2 lines
iostream.cons/
2 lines
2 lines
istream.formatted/
istream.formatted.arithmetic/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
2 lines
2 lines
2 lines
2 lines
2 lines
istream_extractors/
6 lines
6 lines
6 lines
istream.manip/
8 lines
istream.rvalue/
2 lines
istream.unformatted/
4 lines
6 lines
8 lines
8 lines
6 lines
8 lines
6 lines
6 lines
4 lines
4 lines
4 lines
4 lines
2 lines
2 lines
2 lines
4 lines
2 lines
4 lines
istream/
istream.assign/
2 lines
2 lines
istream.cons/
2 lines
2 lines
istream_sentry/
59 lines
output.streams/
ostream.assign/
2 lines
2 lines
ostream.cons/
2 lines
2 lines
ostream.formatted/
ostream.inserters.character/
2 lines
2 lines
2 lines
2 lines
ostream.manip/
2 lines
2 lines
2 lines
ostream.rvalue/
2 lines
ostream.unformatted/
24 lines
24 lines
quoted.manip/
21 lines
1 line
std.manip/
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
iostream.forward/
43 lines
iostream.objects/
53 lines
wide.stream.objects/
1 line
2 lines
1 line
1 line
iostreams.base/
ios/
basic.ios.members/
2 lines
stream.buffers/
streambuf/
streambuf.cons/
12 lines
5 lines
streambuf.protected/
streambuf.assign/
14 lines
14 lines
streambuf.get.area/
2 lines
2 lines
streambuf.put.area/
2 lines
2 lines
2 lines
string.streams/
istringstream/
istringstream.assign/
2 lines
2 lines
2 lines
istringstream.cons/
4 lines
2 lines
2 lines
istringstream.members/
2 lines
ostringstream/
ostringstream.assign/
2 lines
2 lines
2 lines
ostringstream.cons/
4 lines
2 lines
2 lines
ostringstream.members/
2 lines
stringbuf/
stringbuf.assign/
2 lines
2 lines
2 lines
stringbuf.cons/
10 lines
2 lines
2 lines
stringbuf.members/
2 lines
stringbuf.virtuals/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
stringstream.cons/
4 lines
2 lines
4 lines
stringstream.assign/
2 lines
2 lines
2 lines
stringstream.members/
2 lines
iterators/
stream.iterators/
istream.iterator/
2 lines
istreambuf.iterator/
istreambuf.iterator.cons/
3 lines
2 lines
2 lines
2 lines
istreambuf.iterator_equal/
2 lines
istreambuf.iterator_op!=/
2 lines
istreambuf.iterator_op++/
2 lines
istreambuf.iterator_op==/
2 lines
istreambuf.iterator_op_astrk/
2 lines
2 lines
istreambuf.iterator_proxy/
2 lines
2 lines
ostream.iterator/
ostream.iterator.cons.des/
2 lines
ostream.iterator.ops/
2 lines
2 lines
ostreambuf.iterator/
ostreambuf.iter.cons/
2 lines
2 lines
ostreambuf.iter.ops/
2 lines
2 lines
2 lines
2 lines
2 lines
language.support/
cstdint/
cstdint.syn/
9 lines
support.limits/
limits/
numeric.limits.members/
7 lines
7 lines
7 lines
localization/
locale.categories/
category.collate/
locale.collate.byname/
4 lines
2 lines
4 lines
2 lines
locale.collate/
3 lines
locale.collate.members/
2 lines
2 lines
2 lines
2 lines
category.ctype/
locale.codecvt.byname/
2 lines
locale.codecvt/
2 lines
locale.codecvt.members/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
locale.ctype.byname/
1 line
1 line
63 lines
1 line
1 line
1 line
1 line
2 lines
2 lines
2 lines
2 lines
4 lines
1 line
1 line
locale.ctype/
2 lines
locale.ctype.members/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
category.messages/
locale.messages/
7 lines
category.monetary/
locale.money.get/
locale.money.get.members/
6 lines
6 lines
6 lines
6 lines
6 lines
9 lines
locale.money.put/
locale.money.put.members/
7 lines
6 lines
18 lines
6 lines
7 lines
9 lines
locale.moneypunct.byname/
12 lines
17 lines
12 lines
12 lines
12 lines
12 lines
12 lines
12 lines
37 lines
locale.moneypunct/
locale.moneypunct.members/
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
12 lines
category.numeric/
locale.nm.put/
7 lines
category.time/
locale.time.get.byname/
2 lines
2 lines
1 line
2 lines
2 lines
2 lines
2 lines
locale.time.get/
locale.time.get.members/
2 lines
2 lines
2 lines
2 lines
facet.numpunct/
locale.numpunct.byname/
6 lines
6 lines
21 lines
locale.numpunct/
3 lines
facet.numpunct.members/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
locale.stdcvt/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
locales/
locale.convenience/
conversions/
conversions.buffer/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
conversions.string/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
locale/
locale.cons/
55 lines
54 lines
55 lines
55 lines
55 lines
55 lines
55 lines
54 lines
55 lines
locale.members/
55 lines
locale.operators/
2 lines
locale.statics/
55 lines
55 lines
namespace/
30 lines
ranges/
range.utility/
range.subrange/
2 lines
re/
re.alg/
re.alg.match/
3 lines
3 lines
4 lines
3 lines
43 lines
2 lines
4 lines
2 lines
re.alg.search/
4 lines
3 lines
4 lines
3 lines
4 lines
2 lines
4 lines
2 lines
re.iter/
re.regiter/
re.regiter.cnstr/
2 lines
2 lines
re.regex/
re.regex.construct/
10 lines
2 lines
re.results/
re.results.all/
2 lines
re.results.const/
2 lines
4 lines
10 lines
2 lines
4 lines
10 lines
re.results.form/
2 lines
4 lines
4 lines
2 lines
re.submatch/
re.submatch.members/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
re.submatch.op/
4 lines
2 lines
15 lines
re.syn/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
re.traits/
25 lines
25 lines
3 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
strings/
basic.string.hash/
2 lines
2 lines
basic.string.literals/
10 lines
basic.string/
string.cons/
2 lines
64 lines
4 lines
2 lines
2 lines
string.iterators/
2 lines
string.nonmembers/
string.io/
10 lines
10 lines
4 lines
4 lines
6 lines
6 lines
c.strings/
2 lines
2 lines
char.traits/
char.traits.specializations/
char.traits.specializations.wchar.t/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
string.classes/
2 lines
string.conversions/
293 lines
247 lines
139 lines
170 lines
237 lines
170 lines
168 lines
169 lines
2 lines
string.view/
string.view.hash/
2 lines
2 lines
string.view.capacity/
4 lines
string.view.cons/
16 lines
3 lines
2 lines
6 lines
string.view.io/
13 lines
string.view.iterators/
22 lines
22 lines
22 lines
22 lines
string.view.modifiers/
2 lines
2 lines
2 lines
string.view.nonmem/
34 lines
string_view.literals/
14 lines
utilities/
format/
format.arguments/
format.arg.store/
2 lines
1 line
1 line
format.args/
2 lines
4 lines
format.formatter/
format.context/
format.context/
2 lines
2 lines
2 lines
2 lines
2 lines
format.formatter.spec/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
format.parse.ctx/
4 lines
format.functions/
6 lines
6 lines
2 lines
6 lines
6 lines
6 lines
6 lines
6 lines
6 lines
6 lines
6 lines
6 lines
6 lines
6 lines
function.objects/
unord.hash/
2 lines
template.bitset/
bitset.members/
6 lines
1 line
utility/
utility.intcmp/
122 lines
support/
12 lines
2 lines
test.support/
2 lines
5 lines
utils/
ci/
13 lines
6 lines
5 lines
libcxx/
test/
1 line

Diff 378349

libcxx/CMakeLists.txt

Show First 20 Lines • Show All 114 Lines • ▼ Show 20 Linesoption(LIBCXX_ENABLE_LOCALIZATION
localization can be useful when porting to platforms that don't support localization can be useful when porting to platforms that don't support
the C locale API (e.g. embedded). When localization is not supported, the C locale API (e.g. embedded). When localization is not supported,
several parts of the library will be disabled: <iostream>, <regex>, <locale> several parts of the library will be disabled: <iostream>, <regex>, <locale>
will be completely unusable, and other parts may be only partly available." ON) will be completely unusable, and other parts may be only partly available." ON)
option(LIBCXX_ENABLE_UNICODE option(LIBCXX_ENABLE_UNICODE
"Whether to include support for Unicode in the library. Disabling Unicode can "Whether to include support for Unicode in the library. Disabling Unicode can
be useful when porting to platforms that don't support UTF-8 encoding (e.g. be useful when porting to platforms that don't support UTF-8 encoding (e.g.
embedded)." ON) embedded)." ON)
option(LIBCXX_ENABLE_WIDE_CHARACTERS
MordanteUnsubmitted
Done
ReplyInline Actions

Can you add this option to docs/BuildingLibcxx.rst?

Is this feature worth mentioning in the release notes?

Mordante: Can you add this option to `docs/BuildingLibcxx.rst`? Is this feature worth mentioning in the…
ldionneAuthorUnsubmitted
Done
ReplyInline Actions

Did both, good suggestions!

As a self note, I don't really like the duplication of information between the CMake file and the Sphinx documentation for build options. They are often out-of-sync and not everything is everywhere. But I just wanted to raise awareness about the situation -- this isn't the right place to fix it.

ldionne: Did both, good suggestions! As a self note, I don't really like the duplication of information…
MordanteUnsubmitted
Done
ReplyInline Actions

I agree I think we mentioned this duplication issue before.

Mordante: I agree I think we mentioned this duplication issue before.
"Whether to include support for wide characters in the library. Disabling
wide character support can be useful when porting to platforms that don't
support the C functionality for wide characters. When wide characters are
not supported, several parts of the library will be disabled, notably the
wide character specializations of std::basic_string." ON)
option(LIBCXX_ENABLE_VENDOR_AVAILABILITY_ANNOTATIONS option(LIBCXX_ENABLE_VENDOR_AVAILABILITY_ANNOTATIONS
"Whether to turn on vendor availability annotations on declarations that depend "Whether to turn on vendor availability annotations on declarations that depend
on definitions in a shared library. By default, we assume that we're not building on definitions in a shared library. By default, we assume that we're not building
libc++ for any specific vendor, and we disable those annotations. Vendors wishing libc++ for any specific vendor, and we disable those annotations. Vendors wishing
to provide compile-time errors when using features unavailable on some version of to provide compile-time errors when using features unavailable on some version of
the shared library they shipped should turn this on and see `include/__availability` the shared library they shipped should turn this on and see `include/__availability`
for more details." OFF) for more details." OFF)
option(LIBCXX_ENABLE_INCOMPLETE_FEATURES option(LIBCXX_ENABLE_INCOMPLETE_FEATURES
▲ Show 20 Lines • Show All 757 Lines • ▼ Show 20 Lines
config_define_if(LIBCXX_BUILD_EXTERNAL_THREAD_LIBRARY _LIBCPP_HAS_THREAD_LIBRARY_EXTERNAL) config_define_if(LIBCXX_BUILD_EXTERNAL_THREAD_LIBRARY _LIBCPP_HAS_THREAD_LIBRARY_EXTERNAL)
config_define_if(LIBCXX_HAS_MUSL_LIBC _LIBCPP_HAS_MUSL_LIBC) config_define_if(LIBCXX_HAS_MUSL_LIBC _LIBCPP_HAS_MUSL_LIBC)
config_define_if(LIBCXX_NO_VCRUNTIME _LIBCPP_NO_VCRUNTIME) config_define_if(LIBCXX_NO_VCRUNTIME _LIBCPP_NO_VCRUNTIME)
config_define_if(LIBCXX_ENABLE_PARALLEL_ALGORITHMS _LIBCPP_HAS_PARALLEL_ALGORITHMS) config_define_if(LIBCXX_ENABLE_PARALLEL_ALGORITHMS _LIBCPP_HAS_PARALLEL_ALGORITHMS)
config_define_if_not(LIBCXX_ENABLE_FILESYSTEM _LIBCPP_HAS_NO_FILESYSTEM_LIBRARY) config_define_if_not(LIBCXX_ENABLE_FILESYSTEM _LIBCPP_HAS_NO_FILESYSTEM_LIBRARY)
config_define_if_not(LIBCXX_ENABLE_RANDOM_DEVICE _LIBCPP_HAS_NO_RANDOM_DEVICE) config_define_if_not(LIBCXX_ENABLE_RANDOM_DEVICE _LIBCPP_HAS_NO_RANDOM_DEVICE)
config_define_if_not(LIBCXX_ENABLE_LOCALIZATION _LIBCPP_HAS_NO_LOCALIZATION) config_define_if_not(LIBCXX_ENABLE_LOCALIZATION _LIBCPP_HAS_NO_LOCALIZATION)
config_define_if_not(LIBCXX_ENABLE_UNICODE _LIBCPP_HAS_NO_UNICODE) config_define_if_not(LIBCXX_ENABLE_UNICODE _LIBCPP_HAS_NO_UNICODE)
config_define_if_not(LIBCXX_ENABLE_WIDE_CHARACTERS _LIBCPP_HAS_NO_WIDE_CHARACTERS)
config_define_if_not(LIBCXX_ENABLE_VENDOR_AVAILABILITY_ANNOTATIONS _LIBCPP_HAS_NO_VENDOR_AVAILABILITY_ANNOTATIONS) config_define_if_not(LIBCXX_ENABLE_VENDOR_AVAILABILITY_ANNOTATIONS _LIBCPP_HAS_NO_VENDOR_AVAILABILITY_ANNOTATIONS)
# Incomplete features get their own specific disabling flags. This makes it # Incomplete features get their own specific disabling flags. This makes it
# easier to grep for target specific flags once the feature is complete. # easier to grep for target specific flags once the feature is complete.
config_define_if_not(LIBCXX_ENABLE_INCOMPLETE_FEATURES _LIBCPP_HAS_NO_INCOMPLETE_FORMAT) config_define_if_not(LIBCXX_ENABLE_INCOMPLETE_FEATURES _LIBCPP_HAS_NO_INCOMPLETE_FORMAT)
config_define_if_not(LIBCXX_ENABLE_INCOMPLETE_FEATURES _LIBCPP_HAS_NO_INCOMPLETE_RANGES) config_define_if_not(LIBCXX_ENABLE_INCOMPLETE_FEATURES _LIBCPP_HAS_NO_INCOMPLETE_RANGES)
if (LIBCXX_ABI_DEFINES) if (LIBCXX_ABI_DEFINES)
set(abi_defines) set(abi_defines)
▲ Show 20 Lines • Show All 73 Lines • Show Last 20 Lines

libcxx/cmake/caches/Generic-no-wide-characters.cmake

libcxx/docs/BuildingLibcxx.rst

libcxx/docs/ReleaseNotes.rst

libcxx/include/CMakeLists.txt

libcxx/include/__algorithm/sort.h

libcxx/include/__config

libcxx/include/__config_site.in

libcxx/include/__format/format_context.h

libcxx/include/__format/format_parse_context.h

libcxx/include/__format/formatter_bool.h

Show First 20 Lines • Show All 79 Lines • ▼ Show 20 Lines
struct _LIBCPP_TEMPLATE_VIS __bool_strings; struct _LIBCPP_TEMPLATE_VIS __bool_strings;
template <> template <>
struct _LIBCPP_TEMPLATE_VIS __bool_strings<char> { struct _LIBCPP_TEMPLATE_VIS __bool_strings<char> {
static constexpr string_view __true{"true"}; static constexpr string_view __true{"true"};
static constexpr string_view __false{"false"}; static constexpr string_view __false{"false"};
}; };
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
template <> template <>
struct _LIBCPP_TEMPLATE_VIS __bool_strings<wchar_t> { struct _LIBCPP_TEMPLATE_VIS __bool_strings<wchar_t> {
static constexpr wstring_view __true{L"true"}; static constexpr wstring_view __true{L"true"};
static constexpr wstring_view __false{L"false"}; static constexpr wstring_view __false{L"false"};
}; };
#endif
MordanteUnsubmitted
Done
ReplyInline Actions

Can you modify formatter_char.h in this directory and disable formatter<char, wchar_t> and formatter<wchar_t, wchar_t>?

Mordante: Can you modify `formatter_char.h` in this directory and disable `formatter<char, wchar_t>` and…
template <class _CharT> template <class _CharT>
using __formatter_bool = __formatter_integral<__parser_bool<_CharT>>; using __formatter_bool = __formatter_integral<__parser_bool<_CharT>>;
} //namespace __format_spec } //namespace __format_spec
// [format.formatter.spec]/2.3 // [format.formatter.spec]/2.3
// For each charT, for each cv-unqualified arithmetic type ArithmeticT other // For each charT, for each cv-unqualified arithmetic type ArithmeticT other
▲ Show 20 Lines • Show All 45 Lines • Show Last 20 Lines

libcxx/include/__format/formatter_char.h

libcxx/include/__functional/hash.h

libcxx/include/__locale

libcxx/include/__mbstate_t.h

  • This file was added.
// -*- C++ -*-
//===----------------------------------------------------------------------===//
ldionneAuthorUnsubmitted
Done
ReplyInline Actions

I'm calling out attention on this file since I'm not really satisfied by the solution, but don't know how to make it better. Suggestions welcome.

This patch was developed on macOS so obviously some of this might not fly out-of-the-box on Linux, but we should find a way to make it work on all platforms, all the time.

ldionne: I'm calling out attention on this file since I'm not really satisfied by the solution, but…
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef _LIBCPP___MBSTATE_T_H
#define _LIBCPP___MBSTATE_T_H
#include <__config>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header
#endif
// TODO(ldionne):
// The goal of this header is to provide mbstate_t without having to pull in
// <wchar.h> or <uchar.h>. This is necessary because we need that type even
// when we don't have (or try to provide) support for wchar_t, because several
// types like std::fpos are defined in terms of mbstate_t.
//
// This is a gruesome hack, but I don't know how to make it cleaner for
// the time being.
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
# include <wchar.h> // for mbstate_t
#else
# include <sys/_types/_mbstate_t.h> // works on Darwin
MordanteUnsubmitted
Done
ReplyInline Actions
#else
- # include <sys/_types/_mbstate_t.h> // works on Darwin
+ # include <bits/types/mbstate_t.h> // works on Linux
#endif

This fixes this compilation error on my system.

Mordante: This fixes this compilation error on my system.
#endif
_LIBCPP_BEGIN_NAMESPACE_STD
using ::mbstate_t _LIBCPP_USING_IF_EXISTS;
_LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___MBSTATE_T_H

libcxx/include/__string

libcxx/include/__utility/cmp.h

libcxx/include/atomic

libcxx/include/codecvt

libcxx/include/cstddef

libcxx/include/experimental/regex

libcxx/include/experimental/string

libcxx/include/filesystem

libcxx/include/format

libcxx/include/iosfwd

libcxx/include/iostream

libcxx/include/istream

libcxx/include/locale

Show First 20 Lines • Show All 209 Lines • ▼ Show 20 Lines
# define _LIBCPP_HAS_CATOPEN 1 # define _LIBCPP_HAS_CATOPEN 1
# include <nl_types.h> # include <nl_types.h>
# endif # endif
#endif #endif
#ifdef _LIBCPP_LOCALE__L_EXTENSIONS #ifdef _LIBCPP_LOCALE__L_EXTENSIONS
#include <__bsd_locale_defaults.h> #include <__bsd_locale_defaults.h>
#else #else
#include <__bsd_locale_fallbacks.h> #include <__bsd_locale_fallbacks.h>
MordanteUnsubmitted
Done
ReplyInline Actions

After fixing mbstate_t this header give me issues.
Commenting out a set of functions fixed my build issues.
For your convenience I created D111492 with my local modifications which is building here
https://buildkite.com/llvm-project/libcxx-ci/builds/5848

Mordante: After fixing `mbstate_t` this header give me issues. Commenting out a set of functions fixed my…
ldionneAuthorUnsubmitted
Done
ReplyInline Actions

Yup thanks, I fixed it locally.

ldionne: Yup thanks, I fixed it locally.
#endif #endif
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header #pragma GCC system_header
#endif #endif
_LIBCPP_PUSH_MACROS _LIBCPP_PUSH_MACROS
#include <__undef_macros> #include <__undef_macros>
▲ Show 20 Lines • Show All 341 Lines • ▼ Show 20 Lines__num_get<_CharT>::__stage2_float_loop(_CharT __ct, bool& __in_units, char& __exp, char* __a, char*& __a_end,
*__a_end++ = __x; *__a_end++ = __x;
if (__f >= 22) if (__f >= 22)
return 0; return 0;
++__dc; ++__dc;
return 0; return 0;
} }
_LIBCPP_EXTERN_TEMPLATE_EVEN_IN_DEBUG_MODE(struct _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS __num_get<char>) _LIBCPP_EXTERN_TEMPLATE_EVEN_IN_DEBUG_MODE(struct _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS __num_get<char>)
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
_LIBCPP_EXTERN_TEMPLATE_EVEN_IN_DEBUG_MODE(struct _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS __num_get<wchar_t>) _LIBCPP_EXTERN_TEMPLATE_EVEN_IN_DEBUG_MODE(struct _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS __num_get<wchar_t>)
#endif
template <class _CharT, class _InputIterator = istreambuf_iterator<_CharT> > template <class _CharT, class _InputIterator = istreambuf_iterator<_CharT> >
class _LIBCPP_TEMPLATE_VIS num_get class _LIBCPP_TEMPLATE_VIS num_get
: public locale::facet, : public locale::facet,
private __num_get<_CharT> private __num_get<_CharT>
{ {
public: public:
typedef _CharT char_type; typedef _CharT char_type;
▲ Show 20 Lines • Show All 521 Lines • ▼ Show 20 Lines if (__libcpp_sscanf_l(__buf.c_str(), _LIBCPP_GET_C_LOCALE, "%p", &__v) != 1)
__err = ios_base::failbit; __err = ios_base::failbit;
// EOF checked // EOF checked
if (__b == __e) if (__b == __e)
__err |= ios_base::eofbit; __err |= ios_base::eofbit;
return __b; return __b;
} }
_LIBCPP_EXTERN_TEMPLATE_EVEN_IN_DEBUG_MODE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS num_get<char>) _LIBCPP_EXTERN_TEMPLATE_EVEN_IN_DEBUG_MODE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS num_get<char>)
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
_LIBCPP_EXTERN_TEMPLATE_EVEN_IN_DEBUG_MODE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS num_get<wchar_t>) _LIBCPP_EXTERN_TEMPLATE_EVEN_IN_DEBUG_MODE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS num_get<wchar_t>)
#endif
struct _LIBCPP_TYPE_VIS __num_put_base struct _LIBCPP_TYPE_VIS __num_put_base
{ {
protected: protected:
static void __format_int(char* __fmt, const char* __len, bool __signd, static void __format_int(char* __fmt, const char* __len, bool __signd,
ios_base::fmtflags __flags); ios_base::fmtflags __flags);
static bool __format_float(char* __fmt, const char* __len, static bool __format_float(char* __fmt, const char* __len,
ios_base::fmtflags __flags); ios_base::fmtflags __flags);
▲ Show 20 Lines • Show All 133 Lines • ▼ Show 20 Lines__num_put<_CharT>::__widen_and_group_float(char* __nb, char* __np, char* __ne,
__oe += __ne - __nf; __oe += __ne - __nf;
if (__np == __ne) if (__np == __ne)
__op = __oe; __op = __oe;
else else
__op = __ob + (__np - __nb); __op = __ob + (__np - __nb);
} }
_LIBCPP_EXTERN_TEMPLATE_EVEN_IN_DEBUG_MODE(struct _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS __num_put<char>) _LIBCPP_EXTERN_TEMPLATE_EVEN_IN_DEBUG_MODE(struct _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS __num_put<char>)
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
_LIBCPP_EXTERN_TEMPLATE_EVEN_IN_DEBUG_MODE(struct _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS __num_put<wchar_t>) _LIBCPP_EXTERN_TEMPLATE_EVEN_IN_DEBUG_MODE(struct _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS __num_put<wchar_t>)
#endif
template <class _CharT, class _OutputIterator = ostreambuf_iterator<_CharT> > template <class _CharT, class _OutputIterator = ostreambuf_iterator<_CharT> >
class _LIBCPP_TEMPLATE_VIS num_put class _LIBCPP_TEMPLATE_VIS num_put
: public locale::facet, : public locale::facet,
private __num_put<_CharT> private __num_put<_CharT>
{ {
public: public:
typedef _CharT char_type; typedef _CharT char_type;
▲ Show 20 Lines • Show All 416 Lines • ▼ Show 20 Linesnum_put<_CharT, _OutputIterator>::do_put(iter_type __s, ios_base& __iob,
else else
__op = __o + (__np - __nar); __op = __o + (__np - __nar);
// [__o, __oe) contains wide number // [__o, __oe) contains wide number
// Stage 3 & 4 // Stage 3 & 4
return __pad_and_output(__s, __o, __op, __oe, __iob, __fl); return __pad_and_output(__s, __o, __op, __oe, __iob, __fl);
} }
_LIBCPP_EXTERN_TEMPLATE_EVEN_IN_DEBUG_MODE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS num_put<char>) _LIBCPP_EXTERN_TEMPLATE_EVEN_IN_DEBUG_MODE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS num_put<char>)
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
_LIBCPP_EXTERN_TEMPLATE_EVEN_IN_DEBUG_MODE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS num_put<wchar_t>) _LIBCPP_EXTERN_TEMPLATE_EVEN_IN_DEBUG_MODE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS num_put<wchar_t>)
#endif
template <class _CharT, class _InputIterator> template <class _CharT, class _InputIterator>
_LIBCPP_HIDDEN _LIBCPP_HIDDEN
int int
__get_up_to_n_digits(_InputIterator& __b, _InputIterator __e, __get_up_to_n_digits(_InputIterator& __b, _InputIterator __e,
ios_base::iostate& __err, const ctype<_CharT>& __ct, int __n) ios_base::iostate& __err, const ctype<_CharT>& __ct, int __n)
{ {
// Precondition: __n >= 1 // Precondition: __n >= 1
▲ Show 20 Lines • Show All 50 Lines • ▼ Show 20 Lines
template <> _LIBCPP_FUNC_VIS const string* __time_get_c_storage<char>::__weeks() const; template <> _LIBCPP_FUNC_VIS const string* __time_get_c_storage<char>::__weeks() const;
template <> _LIBCPP_FUNC_VIS const string* __time_get_c_storage<char>::__months() const; template <> _LIBCPP_FUNC_VIS const string* __time_get_c_storage<char>::__months() const;
template <> _LIBCPP_FUNC_VIS const string* __time_get_c_storage<char>::__am_pm() const; template <> _LIBCPP_FUNC_VIS const string* __time_get_c_storage<char>::__am_pm() const;
template <> _LIBCPP_FUNC_VIS const string& __time_get_c_storage<char>::__c() const; template <> _LIBCPP_FUNC_VIS const string& __time_get_c_storage<char>::__c() const;
template <> _LIBCPP_FUNC_VIS const string& __time_get_c_storage<char>::__r() const; template <> _LIBCPP_FUNC_VIS const string& __time_get_c_storage<char>::__r() const;
template <> _LIBCPP_FUNC_VIS const string& __time_get_c_storage<char>::__x() const; template <> _LIBCPP_FUNC_VIS const string& __time_get_c_storage<char>::__x() const;
template <> _LIBCPP_FUNC_VIS const string& __time_get_c_storage<char>::__X() const; template <> _LIBCPP_FUNC_VIS const string& __time_get_c_storage<char>::__X() const;
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
template <> _LIBCPP_FUNC_VIS const wstring* __time_get_c_storage<wchar_t>::__weeks() const; template <> _LIBCPP_FUNC_VIS const wstring* __time_get_c_storage<wchar_t>::__weeks() const;
template <> _LIBCPP_FUNC_VIS const wstring* __time_get_c_storage<wchar_t>::__months() const; template <> _LIBCPP_FUNC_VIS const wstring* __time_get_c_storage<wchar_t>::__months() const;
template <> _LIBCPP_FUNC_VIS const wstring* __time_get_c_storage<wchar_t>::__am_pm() const; template <> _LIBCPP_FUNC_VIS const wstring* __time_get_c_storage<wchar_t>::__am_pm() const;
template <> _LIBCPP_FUNC_VIS const wstring& __time_get_c_storage<wchar_t>::__c() const; template <> _LIBCPP_FUNC_VIS const wstring& __time_get_c_storage<wchar_t>::__c() const;
template <> _LIBCPP_FUNC_VIS const wstring& __time_get_c_storage<wchar_t>::__r() const; template <> _LIBCPP_FUNC_VIS const wstring& __time_get_c_storage<wchar_t>::__r() const;
template <> _LIBCPP_FUNC_VIS const wstring& __time_get_c_storage<wchar_t>::__x() const; template <> _LIBCPP_FUNC_VIS const wstring& __time_get_c_storage<wchar_t>::__x() const;
template <> _LIBCPP_FUNC_VIS const wstring& __time_get_c_storage<wchar_t>::__X() const; template <> _LIBCPP_FUNC_VIS const wstring& __time_get_c_storage<wchar_t>::__X() const;
#endif
template <class _CharT, class _InputIterator = istreambuf_iterator<_CharT> > template <class _CharT, class _InputIterator = istreambuf_iterator<_CharT> >
class _LIBCPP_TEMPLATE_VIS time_get class _LIBCPP_TEMPLATE_VIS time_get
: public locale::facet, : public locale::facet,
public time_base, public time_base,
private __time_get_c_storage<_CharT> private __time_get_c_storage<_CharT>
{ {
public: public:
▲ Show 20 Lines • Show All 596 Lines • ▼ Show 20 Lines case '%':
break; break;
default: default:
__err |= ios_base::failbit; __err |= ios_base::failbit;
} }
return __b; return __b;
} }
_LIBCPP_EXTERN_TEMPLATE_EVEN_IN_DEBUG_MODE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS time_get<char>) _LIBCPP_EXTERN_TEMPLATE_EVEN_IN_DEBUG_MODE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS time_get<char>)
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
_LIBCPP_EXTERN_TEMPLATE_EVEN_IN_DEBUG_MODE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS time_get<wchar_t>) _LIBCPP_EXTERN_TEMPLATE_EVEN_IN_DEBUG_MODE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS time_get<wchar_t>)
#endif
class _LIBCPP_TYPE_VIS __time_get class _LIBCPP_TYPE_VIS __time_get
{ {
protected: protected:
locale_t __loc_; locale_t __loc_;
__time_get(const char* __nm); __time_get(const char* __nm);
__time_get(const string& __nm); __time_get(const string& __nm);
▲ Show 20 Lines • Show All 83 Lines • ▼ Show 20 Linesprivate:
virtual const string_type& __r() const {return this->__r_;} virtual const string_type& __r() const {return this->__r_;}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
virtual const string_type& __x() const {return this->__x_;} virtual const string_type& __x() const {return this->__x_;}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
virtual const string_type& __X() const {return this->__X_;} virtual const string_type& __X() const {return this->__X_;}
}; };
_LIBCPP_EXTERN_TEMPLATE_EVEN_IN_DEBUG_MODE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS time_get_byname<char>) _LIBCPP_EXTERN_TEMPLATE_EVEN_IN_DEBUG_MODE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS time_get_byname<char>)
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
_LIBCPP_EXTERN_TEMPLATE_EVEN_IN_DEBUG_MODE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS time_get_byname<wchar_t>) _LIBCPP_EXTERN_TEMPLATE_EVEN_IN_DEBUG_MODE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS time_get_byname<wchar_t>)
#endif
class _LIBCPP_TYPE_VIS __time_put class _LIBCPP_TYPE_VIS __time_put
{ {
locale_t __loc_; locale_t __loc_;
protected: protected:
_LIBCPP_INLINE_VISIBILITY __time_put() : __loc_(_LIBCPP_GET_C_LOCALE) {} _LIBCPP_INLINE_VISIBILITY __time_put() : __loc_(_LIBCPP_GET_C_LOCALE) {}
__time_put(const char* __nm); __time_put(const char* __nm);
__time_put(const string& __nm); __time_put(const string& __nm);
▲ Show 20 Lines • Show All 96 Lines • ▼ Show 20 Linestime_put<_CharT, _OutputIterator>::do_put(iter_type __s, ios_base&,
char_type __nar[100]; char_type __nar[100];
char_type* __nb = __nar; char_type* __nb = __nar;
char_type* __ne = __nb + 100; char_type* __ne = __nb + 100;
__do_put(__nb, __ne, __tm, __fmt, __mod); __do_put(__nb, __ne, __tm, __fmt, __mod);
return _VSTD::copy(__nb, __ne, __s); return _VSTD::copy(__nb, __ne, __s);
} }
_LIBCPP_EXTERN_TEMPLATE_EVEN_IN_DEBUG_MODE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS time_put<char>) _LIBCPP_EXTERN_TEMPLATE_EVEN_IN_DEBUG_MODE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS time_put<char>)
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
_LIBCPP_EXTERN_TEMPLATE_EVEN_IN_DEBUG_MODE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS time_put<wchar_t>) _LIBCPP_EXTERN_TEMPLATE_EVEN_IN_DEBUG_MODE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS time_put<wchar_t>)
#endif
template <class _CharT, class _OutputIterator = ostreambuf_iterator<_CharT> > template <class _CharT, class _OutputIterator = ostreambuf_iterator<_CharT> >
class _LIBCPP_TEMPLATE_VIS time_put_byname class _LIBCPP_TEMPLATE_VIS time_put_byname
: public time_put<_CharT, _OutputIterator> : public time_put<_CharT, _OutputIterator>
{ {
public: public:
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
explicit time_put_byname(const char* __nm, size_t __refs = 0) explicit time_put_byname(const char* __nm, size_t __refs = 0)
: time_put<_CharT, _OutputIterator>(__nm, __refs) {} : time_put<_CharT, _OutputIterator>(__nm, __refs) {}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
explicit time_put_byname(const string& __nm, size_t __refs = 0) explicit time_put_byname(const string& __nm, size_t __refs = 0)
: time_put<_CharT, _OutputIterator>(__nm, __refs) {} : time_put<_CharT, _OutputIterator>(__nm, __refs) {}
protected: protected:
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
~time_put_byname() {} ~time_put_byname() {}
}; };
_LIBCPP_EXTERN_TEMPLATE_EVEN_IN_DEBUG_MODE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS time_put_byname<char>) _LIBCPP_EXTERN_TEMPLATE_EVEN_IN_DEBUG_MODE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS time_put_byname<char>)
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
_LIBCPP_EXTERN_TEMPLATE_EVEN_IN_DEBUG_MODE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS time_put_byname<wchar_t>) _LIBCPP_EXTERN_TEMPLATE_EVEN_IN_DEBUG_MODE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS time_put_byname<wchar_t>)
#endif
// money_base // money_base
class _LIBCPP_TYPE_VIS money_base class _LIBCPP_TYPE_VIS money_base
{ {
public: public:
enum part {none, space, symbol, sign, value}; enum part {none, space, symbol, sign, value};
struct pattern {char field[4];}; struct pattern {char field[4];};
▲ Show 20 Lines • Show All 51 Lines • ▼ Show 20 Lines
moneypunct<_CharT, _International>::id; moneypunct<_CharT, _International>::id;
template <class _CharT, bool _International> template <class _CharT, bool _International>
const bool const bool
moneypunct<_CharT, _International>::intl; moneypunct<_CharT, _International>::intl;
_LIBCPP_EXTERN_TEMPLATE_EVEN_IN_DEBUG_MODE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS moneypunct<char, false>) _LIBCPP_EXTERN_TEMPLATE_EVEN_IN_DEBUG_MODE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS moneypunct<char, false>)
_LIBCPP_EXTERN_TEMPLATE_EVEN_IN_DEBUG_MODE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS moneypunct<char, true>) _LIBCPP_EXTERN_TEMPLATE_EVEN_IN_DEBUG_MODE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS moneypunct<char, true>)
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
_LIBCPP_EXTERN_TEMPLATE_EVEN_IN_DEBUG_MODE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS moneypunct<wchar_t, false>) _LIBCPP_EXTERN_TEMPLATE_EVEN_IN_DEBUG_MODE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS moneypunct<wchar_t, false>)
_LIBCPP_EXTERN_TEMPLATE_EVEN_IN_DEBUG_MODE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS moneypunct<wchar_t, true>) _LIBCPP_EXTERN_TEMPLATE_EVEN_IN_DEBUG_MODE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS moneypunct<wchar_t, true>)
#endif
// moneypunct_byname // moneypunct_byname
template <class _CharT, bool _International = false> template <class _CharT, bool _International = false>
class _LIBCPP_TEMPLATE_VIS moneypunct_byname class _LIBCPP_TEMPLATE_VIS moneypunct_byname
: public moneypunct<_CharT, _International> : public moneypunct<_CharT, _International>
{ {
public: public:
Show All 34 Linesprivate:
pattern __pos_format_; pattern __pos_format_;
pattern __neg_format_; pattern __neg_format_;
void init(const char*); void init(const char*);
}; };
template<> _LIBCPP_FUNC_VIS void moneypunct_byname<char, false>::init(const char*); template<> _LIBCPP_FUNC_VIS void moneypunct_byname<char, false>::init(const char*);
template<> _LIBCPP_FUNC_VIS void moneypunct_byname<char, true>::init(const char*); template<> _LIBCPP_FUNC_VIS void moneypunct_byname<char, true>::init(const char*);
template<> _LIBCPP_FUNC_VIS void moneypunct_byname<wchar_t, false>::init(const char*);
template<> _LIBCPP_FUNC_VIS void moneypunct_byname<wchar_t, true>::init(const char*);
_LIBCPP_EXTERN_TEMPLATE_EVEN_IN_DEBUG_MODE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS moneypunct_byname<char, false>) _LIBCPP_EXTERN_TEMPLATE_EVEN_IN_DEBUG_MODE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS moneypunct_byname<char, false>)
_LIBCPP_EXTERN_TEMPLATE_EVEN_IN_DEBUG_MODE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS moneypunct_byname<char, true>) _LIBCPP_EXTERN_TEMPLATE_EVEN_IN_DEBUG_MODE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS moneypunct_byname<char, true>)
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
template<> _LIBCPP_FUNC_VIS void moneypunct_byname<wchar_t, false>::init(const char*);
template<> _LIBCPP_FUNC_VIS void moneypunct_byname<wchar_t, true>::init(const char*);
_LIBCPP_EXTERN_TEMPLATE_EVEN_IN_DEBUG_MODE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS moneypunct_byname<wchar_t, false>) _LIBCPP_EXTERN_TEMPLATE_EVEN_IN_DEBUG_MODE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS moneypunct_byname<wchar_t, false>)
_LIBCPP_EXTERN_TEMPLATE_EVEN_IN_DEBUG_MODE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS moneypunct_byname<wchar_t, true>) _LIBCPP_EXTERN_TEMPLATE_EVEN_IN_DEBUG_MODE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS moneypunct_byname<wchar_t, true>)
#endif
// money_get // money_get
template <class _CharT> template <class _CharT>
class __money_get class __money_get
{ {
protected: protected:
typedef _CharT char_type; typedef _CharT char_type;
Show All 40 Lines else
__ts = __mp.thousands_sep(); __ts = __mp.thousands_sep();
__grp = __mp.grouping(); __grp = __mp.grouping();
__sym = __mp.curr_symbol(); __sym = __mp.curr_symbol();
__fd = __mp.frac_digits(); __fd = __mp.frac_digits();
} }
} }
_LIBCPP_EXTERN_TEMPLATE_EVEN_IN_DEBUG_MODE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS __money_get<char>) _LIBCPP_EXTERN_TEMPLATE_EVEN_IN_DEBUG_MODE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS __money_get<char>)
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
_LIBCPP_EXTERN_TEMPLATE_EVEN_IN_DEBUG_MODE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS __money_get<wchar_t>) _LIBCPP_EXTERN_TEMPLATE_EVEN_IN_DEBUG_MODE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS __money_get<wchar_t>)
#endif
template <class _CharT, class _InputIterator = istreambuf_iterator<_CharT> > template <class _CharT, class _InputIterator = istreambuf_iterator<_CharT> >
class _LIBCPP_TEMPLATE_VIS money_get class _LIBCPP_TEMPLATE_VIS money_get
: public locale::facet, : public locale::facet,
private __money_get<_CharT> private __money_get<_CharT>
{ {
public: public:
typedef _CharT char_type; typedef _CharT char_type;
▲ Show 20 Lines • Show All 370 Lines • ▼ Show 20 Lines if (__do_get(__b, __e, __intl, __loc, __iob.flags(), __err, __neg, __ct,
__v.append(__w, __wn); __v.append(__w, __wn);
} }
if (__b == __e) if (__b == __e)
__err |= ios_base::eofbit; __err |= ios_base::eofbit;
return __b; return __b;
} }
_LIBCPP_EXTERN_TEMPLATE_EVEN_IN_DEBUG_MODE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS money_get<char>) _LIBCPP_EXTERN_TEMPLATE_EVEN_IN_DEBUG_MODE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS money_get<char>)
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
_LIBCPP_EXTERN_TEMPLATE_EVEN_IN_DEBUG_MODE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS money_get<wchar_t>) _LIBCPP_EXTERN_TEMPLATE_EVEN_IN_DEBUG_MODE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS money_get<wchar_t>)
#endif
// money_put // money_put
template <class _CharT> template <class _CharT>
class __money_put class __money_put
{ {
protected: protected:
typedef _CharT char_type; typedef _CharT char_type;
▲ Show 20 Lines • Show All 158 Lines • ▼ Show 20 Lines__money_put<_CharT>::__format(char_type* __mb, char_type*& __mi, char_type*& __me,
// set alignment // set alignment
if ((__flags & ios_base::adjustfield) == ios_base::left) if ((__flags & ios_base::adjustfield) == ios_base::left)
__mi = __me; __mi = __me;
else if ((__flags & ios_base::adjustfield) != ios_base::internal) else if ((__flags & ios_base::adjustfield) != ios_base::internal)
__mi = __mb; __mi = __mb;
} }
_LIBCPP_EXTERN_TEMPLATE_EVEN_IN_DEBUG_MODE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS __money_put<char>) _LIBCPP_EXTERN_TEMPLATE_EVEN_IN_DEBUG_MODE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS __money_put<char>)
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
_LIBCPP_EXTERN_TEMPLATE_EVEN_IN_DEBUG_MODE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS __money_put<wchar_t>) _LIBCPP_EXTERN_TEMPLATE_EVEN_IN_DEBUG_MODE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS __money_put<wchar_t>)
#endif
template <class _CharT, class _OutputIterator = ostreambuf_iterator<_CharT> > template <class _CharT, class _OutputIterator = ostreambuf_iterator<_CharT> >
class _LIBCPP_TEMPLATE_VIS money_put class _LIBCPP_TEMPLATE_VIS money_put
: public locale::facet, : public locale::facet,
private __money_put<_CharT> private __money_put<_CharT>
{ {
public: public:
typedef _CharT char_type; typedef _CharT char_type;
▲ Show 20 Lines • Show All 136 Lines • ▼ Show 20 Linesmoney_put<_CharT, _OutputIterator>::do_put(iter_type __s, bool __intl,
char_type* __me; char_type* __me;
this->__format(__mb, __mi, __me, __iob.flags(), this->__format(__mb, __mi, __me, __iob.flags(),
__digits.data(), __digits.data() + __digits.size(), __ct, __digits.data(), __digits.data() + __digits.size(), __ct,
__neg, __pat, __dp, __ts, __grp, __sym, __sn, __fd); __neg, __pat, __dp, __ts, __grp, __sym, __sn, __fd);
return __pad_and_output(__s, __mb, __mi, __me, __iob, __fl); return __pad_and_output(__s, __mb, __mi, __me, __iob, __fl);
} }
_LIBCPP_EXTERN_TEMPLATE_EVEN_IN_DEBUG_MODE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS money_put<char>) _LIBCPP_EXTERN_TEMPLATE_EVEN_IN_DEBUG_MODE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS money_put<char>)
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
_LIBCPP_EXTERN_TEMPLATE_EVEN_IN_DEBUG_MODE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS money_put<wchar_t>) _LIBCPP_EXTERN_TEMPLATE_EVEN_IN_DEBUG_MODE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS money_put<wchar_t>)
#endif
// messages // messages
class _LIBCPP_TYPE_VIS messages_base class _LIBCPP_TYPE_VIS messages_base
{ {
public: public:
typedef ptrdiff_t catalog; typedef ptrdiff_t catalog;
▲ Show 20 Lines • Show All 99 Lines • ▼ Show 20 Lines#ifdef _LIBCPP_HAS_CATOPEN
nl_catd __cat = (nl_catd)__c; nl_catd __cat = (nl_catd)__c;
catclose(__cat); catclose(__cat);
#else // !_LIBCPP_HAS_CATOPEN #else // !_LIBCPP_HAS_CATOPEN
(void)__c; (void)__c;
#endif // _LIBCPP_HAS_CATOPEN #endif // _LIBCPP_HAS_CATOPEN
} }
_LIBCPP_EXTERN_TEMPLATE_EVEN_IN_DEBUG_MODE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS messages<char>) _LIBCPP_EXTERN_TEMPLATE_EVEN_IN_DEBUG_MODE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS messages<char>)
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
_LIBCPP_EXTERN_TEMPLATE_EVEN_IN_DEBUG_MODE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS messages<wchar_t>) _LIBCPP_EXTERN_TEMPLATE_EVEN_IN_DEBUG_MODE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS messages<wchar_t>)
#endif
template <class _CharT> template <class _CharT>
class _LIBCPP_TEMPLATE_VIS messages_byname class _LIBCPP_TEMPLATE_VIS messages_byname
: public messages<_CharT> : public messages<_CharT>
{ {
public: public:
typedef messages_base::catalog catalog; typedef messages_base::catalog catalog;
typedef basic_string<_CharT> string_type; typedef basic_string<_CharT> string_type;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
explicit messages_byname(const char*, size_t __refs = 0) explicit messages_byname(const char*, size_t __refs = 0)
: messages<_CharT>(__refs) {} : messages<_CharT>(__refs) {}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
explicit messages_byname(const string&, size_t __refs = 0) explicit messages_byname(const string&, size_t __refs = 0)
: messages<_CharT>(__refs) {} : messages<_CharT>(__refs) {}
protected: protected:
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
~messages_byname() {} ~messages_byname() {}
}; };
_LIBCPP_EXTERN_TEMPLATE_EVEN_IN_DEBUG_MODE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS messages_byname<char>) _LIBCPP_EXTERN_TEMPLATE_EVEN_IN_DEBUG_MODE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS messages_byname<char>)
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
_LIBCPP_EXTERN_TEMPLATE_EVEN_IN_DEBUG_MODE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS messages_byname<wchar_t>) _LIBCPP_EXTERN_TEMPLATE_EVEN_IN_DEBUG_MODE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS messages_byname<wchar_t>)
#endif
template<class _Codecvt, class _Elem = wchar_t, template<class _Codecvt, class _Elem = wchar_t,
class _Wide_alloc = allocator<_Elem>, class _Wide_alloc = allocator<_Elem>,
class _Byte_alloc = allocator<char> > class _Byte_alloc = allocator<char> >
class _LIBCPP_TEMPLATE_VIS wstring_convert class _LIBCPP_TEMPLATE_VIS wstring_convert
{ {
public: public:
typedef basic_string<char, char_traits<char>, _Byte_alloc> byte_string; typedef basic_string<char, char_traits<char>, _Byte_alloc> byte_string;
▲ Show 20 Lines • Show All 731 Lines • Show Last 20 Lines

libcxx/include/module.modulemap

libcxx/include/ostream

libcxx/include/regex

Show First 20 Lines • Show All 1,064 Lines • ▼ Show 20 Linespublic:
locale_type imbue(locale_type __l); locale_type imbue(locale_type __l);
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
locale_type getloc()const {return __loc_;} locale_type getloc()const {return __loc_;}
private: private:
void __init(); void __init();
template <class _ForwardIterator> template <class _ForwardIterator>
string_type string_type
MordanteUnsubmitted
Done
ReplyInline Actions

I'm not fond of formatting changes in this patch. I would strongly recommend to just commit the format changes now so this patch looks cleaner.

Mordante: I'm not fond of formatting changes in this patch. I would strongly recommend to just commit the…
ldionneAuthorUnsubmitted
Done
ReplyInline Actions

You're right, sorry this slipped through. It should be one of the only places where there are such changes, and I'll avoid touching the formatting at all.

ldionne: You're right, sorry this slipped through. It should be one of the only places where there are…
__transform_primary(_ForwardIterator __f, _ForwardIterator __l, char) const; __transform_primary(_ForwardIterator __f, _ForwardIterator __l, char) const;
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
template <class _ForwardIterator> template <class _ForwardIterator>
string_type string_type
__transform_primary(_ForwardIterator __f, _ForwardIterator __l, wchar_t) const; __transform_primary(_ForwardIterator __f, _ForwardIterator __l, wchar_t) const;
#endif
template <class _ForwardIterator> template <class _ForwardIterator>
string_type string_type
__lookup_collatename(_ForwardIterator __f, _ForwardIterator __l, char) const; __lookup_collatename(_ForwardIterator __f, _ForwardIterator __l, char) const;
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
template <class _ForwardIterator> template <class _ForwardIterator>
string_type string_type
__lookup_collatename(_ForwardIterator __f, _ForwardIterator __l, wchar_t) const; __lookup_collatename(_ForwardIterator __f, _ForwardIterator __l, wchar_t) const;
#endif
template <class _ForwardIterator> template <class _ForwardIterator>
char_class_type char_class_type
__lookup_classname(_ForwardIterator __f, _ForwardIterator __l, __lookup_classname(_ForwardIterator __f, _ForwardIterator __l,
bool __icase, char) const; bool __icase, char) const;
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
template <class _ForwardIterator> template <class _ForwardIterator>
char_class_type char_class_type
__lookup_classname(_ForwardIterator __f, _ForwardIterator __l, __lookup_classname(_ForwardIterator __f, _ForwardIterator __l,
bool __icase, wchar_t) const; bool __icase, wchar_t) const;
#endif
static int __regex_traits_value(unsigned char __ch, int __radix); static int __regex_traits_value(unsigned char __ch, int __radix);
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
int __regex_traits_value(char __ch, int __radix) const int __regex_traits_value(char __ch, int __radix) const
{return __regex_traits_value(static_cast<unsigned char>(__ch), __radix);} {return __regex_traits_value(static_cast<unsigned char>(__ch), __radix);}
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
int __regex_traits_value(wchar_t __ch, int __radix) const; int __regex_traits_value(wchar_t __ch, int __radix) const;
#endif
}; };
template <class _CharT> template <class _CharT>
const typename regex_traits<_CharT>::char_class_type const typename regex_traits<_CharT>::char_class_type
regex_traits<_CharT>::__regex_word; regex_traits<_CharT>::__regex_word;
template <class _CharT> template <class _CharT>
regex_traits<_CharT>::regex_traits() regex_traits<_CharT>::regex_traits()
▲ Show 20 Lines • Show All 54 Lines • ▼ Show 20 Lines case 12:
break; break;
default: default:
__d.clear(); __d.clear();
break; break;
} }
return __d; return __d;
} }
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
template <class _CharT> template <class _CharT>
template <class _ForwardIterator> template <class _ForwardIterator>
typename regex_traits<_CharT>::string_type typename regex_traits<_CharT>::string_type
regex_traits<_CharT>::__transform_primary(_ForwardIterator __f, regex_traits<_CharT>::__transform_primary(_ForwardIterator __f,
_ForwardIterator __l, wchar_t) const _ForwardIterator __l, wchar_t) const
{ {
const string_type __s(__f, __l); const string_type __s(__f, __l);
string_type __d = __col_->transform(__s.data(), __s.data() + __s.size()); string_type __d = __col_->transform(__s.data(), __s.data() + __s.size());
switch (__d.size()) switch (__d.size())
{ {
case 1: case 1:
break; break;
case 3: case 3:
__d[2] = __d[0]; __d[2] = __d[0];
break; break;
default: default:
__d.clear(); __d.clear();
break; break;
} }
return __d; return __d;
} }
#endif
// lookup_collatename is very FreeBSD-specific // lookup_collatename is very FreeBSD-specific
_LIBCPP_FUNC_VIS string __get_collation_name(const char* __s); _LIBCPP_FUNC_VIS string __get_collation_name(const char* __s);
template <class _CharT> template <class _CharT>
template <class _ForwardIterator> template <class _ForwardIterator>
typename regex_traits<_CharT>::string_type typename regex_traits<_CharT>::string_type
Show All 12 Lines if (!__s.empty())
__r = __s; __r = __s;
else else
__r.clear(); __r.clear();
} }
} }
return __r; return __r;
} }
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
template <class _CharT> template <class _CharT>
template <class _ForwardIterator> template <class _ForwardIterator>
typename regex_traits<_CharT>::string_type typename regex_traits<_CharT>::string_type
regex_traits<_CharT>::__lookup_collatename(_ForwardIterator __f, regex_traits<_CharT>::__lookup_collatename(_ForwardIterator __f,
_ForwardIterator __l, wchar_t) const _ForwardIterator __l, wchar_t) const
{ {
string_type __s(__f, __l); string_type __s(__f, __l);
string __n; string __n;
Show All 17 Lines if (!__s.empty())
if (__r.size() == 1 || __r.size() == 3) if (__r.size() == 1 || __r.size() == 3)
__r = __s; __r = __s;
else else
__r.clear(); __r.clear();
} }
} }
return __r; return __r;
} }
#endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
// lookup_classname // lookup_classname
regex_traits<char>::char_class_type _LIBCPP_FUNC_VIS regex_traits<char>::char_class_type _LIBCPP_FUNC_VIS
__get_classname(const char* __s, bool __icase); __get_classname(const char* __s, bool __icase);
template <class _CharT> template <class _CharT>
template <class _ForwardIterator> template <class _ForwardIterator>
typename regex_traits<_CharT>::char_class_type typename regex_traits<_CharT>::char_class_type
regex_traits<_CharT>::__lookup_classname(_ForwardIterator __f, regex_traits<_CharT>::__lookup_classname(_ForwardIterator __f,
_ForwardIterator __l, _ForwardIterator __l,
bool __icase, char) const bool __icase, char) const
{ {
string_type __s(__f, __l); string_type __s(__f, __l);
__ct_->tolower(&__s[0], &__s[0] + __s.size()); __ct_->tolower(&__s[0], &__s[0] + __s.size());
return __get_classname(__s.c_str(), __icase); return __get_classname(__s.c_str(), __icase);
} }
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
template <class _CharT> template <class _CharT>
template <class _ForwardIterator> template <class _ForwardIterator>
typename regex_traits<_CharT>::char_class_type typename regex_traits<_CharT>::char_class_type
regex_traits<_CharT>::__lookup_classname(_ForwardIterator __f, regex_traits<_CharT>::__lookup_classname(_ForwardIterator __f,
_ForwardIterator __l, _ForwardIterator __l,
bool __icase, wchar_t) const bool __icase, wchar_t) const
{ {
string_type __s(__f, __l); string_type __s(__f, __l);
__ct_->tolower(&__s[0], &__s[0] + __s.size()); __ct_->tolower(&__s[0], &__s[0] + __s.size());
string __n; string __n;
__n.reserve(__s.size()); __n.reserve(__s.size());
for (typename string_type::const_iterator __i = __s.begin(), __e = __s.end(); for (typename string_type::const_iterator __i = __s.begin(), __e = __s.end();
__i != __e; ++__i) __i != __e; ++__i)
{ {
if (static_cast<unsigned>(*__i) >= 127) if (static_cast<unsigned>(*__i) >= 127)
return char_class_type(); return char_class_type();
__n.push_back(char(*__i)); __n.push_back(char(*__i));
} }
return __get_classname(__n.c_str(), __icase); return __get_classname(__n.c_str(), __icase);
} }
#endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
template <class _CharT> template <class _CharT>
bool bool
regex_traits<_CharT>::isctype(char_type __c, char_class_type __m) const regex_traits<_CharT>::isctype(char_type __c, char_class_type __m) const
{ {
if (__ct_->is(__m, __c)) if (__ct_->is(__m, __c))
return true; return true;
return (__c == '_' && (__m & __regex_word)); return (__c == '_' && (__m & __regex_word));
Show All 14 Lines if (__radix != 8)
__ch |= 0x20; // tolower __ch |= 0x20; // tolower
if ('a' <= __ch && __ch <= 'f') if ('a' <= __ch && __ch <= 'f')
return __ch - ('a' - 10); return __ch - ('a' - 10);
} }
} }
return -1; return -1;
} }
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
template <class _CharT> template <class _CharT>
inline inline
int int
regex_traits<_CharT>::__regex_traits_value(wchar_t __ch, int __radix) const regex_traits<_CharT>::__regex_traits_value(wchar_t __ch, int __radix) const
{ {
return __regex_traits_value(static_cast<unsigned char>(__ct_->narrow(__ch, char_type())), __radix); return __regex_traits_value(static_cast<unsigned char>(__ct_->narrow(__ch, char_type())), __radix);
} }
#endif
template <class _CharT> class __node; template <class _CharT> class __node;
template <class _BidirectionalIterator> class _LIBCPP_TEMPLATE_VIS sub_match; template <class _BidirectionalIterator> class _LIBCPP_TEMPLATE_VIS sub_match;
template <class _BidirectionalIterator, template <class _BidirectionalIterator,
class _Allocator = allocator<sub_match<_BidirectionalIterator> > > class _Allocator = allocator<sub_match<_BidirectionalIterator> > >
class _LIBCPP_TEMPLATE_VIS match_results; class _LIBCPP_TEMPLATE_VIS match_results;
▲ Show 20 Lines • Show All 794 Lines • ▼ Show 20 Linespublic:
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
__match_any_but_newline(__node<_CharT>* __s) __match_any_but_newline(__node<_CharT>* __s)
: base(__s) {} : base(__s) {}
virtual void __exec(__state&) const; virtual void __exec(__state&) const;
}; };
template <> _LIBCPP_FUNC_VIS void __match_any_but_newline<char>::__exec(__state&) const; template <> _LIBCPP_FUNC_VIS void __match_any_but_newline<char>::__exec(__state&) const;
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
template <> _LIBCPP_FUNC_VIS void __match_any_but_newline<wchar_t>::__exec(__state&) const; template <> _LIBCPP_FUNC_VIS void __match_any_but_newline<wchar_t>::__exec(__state&) const;
#endif
// __match_char // __match_char
template <class _CharT> template <class _CharT>
class __match_char class __match_char
: public __owns_one_state<_CharT> : public __owns_one_state<_CharT>
{ {
typedef __owns_one_state<_CharT> base; typedef __owns_one_state<_CharT> base;
▲ Show 20 Lines • Show All 390 Lines • ▼ Show 20 Lines
} }
template <class _CharT, class _Traits> class __lookahead; template <class _CharT, class _Traits> class __lookahead;
template <class _CharT, class _Traits = regex_traits<_CharT> > template <class _CharT, class _Traits = regex_traits<_CharT> >
class _LIBCPP_TEMPLATE_VIS basic_regex; class _LIBCPP_TEMPLATE_VIS basic_regex;
typedef basic_regex<char> regex; typedef basic_regex<char> regex;
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
typedef basic_regex<wchar_t> wregex; typedef basic_regex<wchar_t> wregex;
#endif
template <class _CharT, class _Traits> template <class _CharT, class _Traits>
class class
_LIBCPP_TEMPLATE_VIS _LIBCPP_TEMPLATE_VIS
_LIBCPP_PREFERRED_NAME(regex) _LIBCPP_PREFERRED_NAME(regex)
_LIBCPP_PREFERRED_NAME(wregex) _LIBCPP_IF_WIDE_CHARACTERS(_LIBCPP_PREFERRED_NAME(wregex))
basic_regex basic_regex
{ {
public: public:
// types: // types:
typedef _CharT value_type; typedef _CharT value_type;
typedef _Traits traits_type; typedef _Traits traits_type;
typedef typename _Traits::string_type string_type; typedef typename _Traits::string_type string_type;
typedef regex_constants::syntax_option_type flag_type; typedef regex_constants::syntax_option_type flag_type;
▲ Show 20 Lines • Show All 2,332 Lines • ▼ Show 20 Linesbasic_regex<_CharT, _Traits>::__push_lookahead(const basic_regex& __exp,
__end_->first() = new __lookahead<_CharT, _Traits>(__exp, __invert, __end_->first() = new __lookahead<_CharT, _Traits>(__exp, __invert,
__end_->first(), __mexp); __end_->first(), __mexp);
__end_ = static_cast<__owns_one_state<_CharT>*>(__end_->first()); __end_ = static_cast<__owns_one_state<_CharT>*>(__end_->first());
} }
// sub_match // sub_match
typedef sub_match<const char*> csub_match; typedef sub_match<const char*> csub_match;
typedef sub_match<const wchar_t*> wcsub_match;
typedef sub_match<string::const_iterator> ssub_match; typedef sub_match<string::const_iterator> ssub_match;
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
typedef sub_match<const wchar_t*> wcsub_match;
typedef sub_match<wstring::const_iterator> wssub_match; typedef sub_match<wstring::const_iterator> wssub_match;
#endif
template <class _BidirectionalIterator> template <class _BidirectionalIterator>
class class
_LIBCPP_TEMPLATE_VIS _LIBCPP_TEMPLATE_VIS
_LIBCPP_PREFERRED_NAME(csub_match) _LIBCPP_PREFERRED_NAME(csub_match)
_LIBCPP_PREFERRED_NAME(wcsub_match) _LIBCPP_IF_WIDE_CHARACTERS(_LIBCPP_PREFERRED_NAME(wcsub_match))
_LIBCPP_PREFERRED_NAME(ssub_match) _LIBCPP_PREFERRED_NAME(ssub_match)
_LIBCPP_PREFERRED_NAME(wssub_match) _LIBCPP_IF_WIDE_CHARACTERS(_LIBCPP_PREFERRED_NAME(wssub_match))
sub_match sub_match
: public pair<_BidirectionalIterator, _BidirectionalIterator> : public pair<_BidirectionalIterator, _BidirectionalIterator>
{ {
public: public:
typedef _BidirectionalIterator iterator; typedef _BidirectionalIterator iterator;
typedef typename iterator_traits<iterator>::value_type value_type; typedef typename iterator_traits<iterator>::value_type value_type;
typedef typename iterator_traits<iterator>::difference_type difference_type; typedef typename iterator_traits<iterator>::difference_type difference_type;
typedef basic_string<value_type> string_type; typedef basic_string<value_type> string_type;
▲ Show 20 Lines • Show All 402 Lines • ▼ Show 20 Lines
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
basic_ostream<_CharT, _ST>& basic_ostream<_CharT, _ST>&
operator<<(basic_ostream<_CharT, _ST>& __os, const sub_match<_BiIter>& __m) operator<<(basic_ostream<_CharT, _ST>& __os, const sub_match<_BiIter>& __m)
{ {
return __os << __m.str(); return __os << __m.str();
} }
typedef match_results<const char*> cmatch; typedef match_results<const char*> cmatch;
typedef match_results<const wchar_t*> wcmatch;
typedef match_results<string::const_iterator> smatch; typedef match_results<string::const_iterator> smatch;
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
typedef match_results<const wchar_t*> wcmatch;
typedef match_results<wstring::const_iterator> wsmatch; typedef match_results<wstring::const_iterator> wsmatch;
#endif
template <class _BidirectionalIterator, class _Allocator> template <class _BidirectionalIterator, class _Allocator>
class class
_LIBCPP_TEMPLATE_VIS _LIBCPP_TEMPLATE_VIS
_LIBCPP_PREFERRED_NAME(cmatch) _LIBCPP_PREFERRED_NAME(cmatch)
_LIBCPP_PREFERRED_NAME(wcmatch) _LIBCPP_IF_WIDE_CHARACTERS(_LIBCPP_PREFERRED_NAME(wcmatch))
_LIBCPP_PREFERRED_NAME(smatch) _LIBCPP_PREFERRED_NAME(smatch)
_LIBCPP_PREFERRED_NAME(wsmatch) _LIBCPP_IF_WIDE_CHARACTERS(_LIBCPP_PREFERRED_NAME(wsmatch))
match_results match_results
{ {
public: public:
typedef _Allocator allocator_type; typedef _Allocator allocator_type;
typedef sub_match<_BidirectionalIterator> value_type; typedef sub_match<_BidirectionalIterator> value_type;
private: private:
typedef vector<value_type, allocator_type> __container_type; typedef vector<value_type, allocator_type> __container_type;
▲ Show 20 Lines • Show All 891 Lines • ▼ Show 20 Lines
// regex_iterator // regex_iterator
template <class _BidirectionalIterator, template <class _BidirectionalIterator,
class _CharT = typename iterator_traits<_BidirectionalIterator>::value_type, class _CharT = typename iterator_traits<_BidirectionalIterator>::value_type,
class _Traits = regex_traits<_CharT> > class _Traits = regex_traits<_CharT> >
class _LIBCPP_TEMPLATE_VIS regex_iterator; class _LIBCPP_TEMPLATE_VIS regex_iterator;
typedef regex_iterator<const char*> cregex_iterator; typedef regex_iterator<const char*> cregex_iterator;
typedef regex_iterator<const wchar_t*> wcregex_iterator;
typedef regex_iterator<string::const_iterator> sregex_iterator; typedef regex_iterator<string::const_iterator> sregex_iterator;
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
typedef regex_iterator<const wchar_t*> wcregex_iterator;
typedef regex_iterator<wstring::const_iterator> wsregex_iterator; typedef regex_iterator<wstring::const_iterator> wsregex_iterator;
#endif
template <class _BidirectionalIterator, class _CharT, class _Traits> template <class _BidirectionalIterator, class _CharT, class _Traits>
class class
_LIBCPP_TEMPLATE_VIS _LIBCPP_TEMPLATE_VIS
_LIBCPP_PREFERRED_NAME(cregex_iterator) _LIBCPP_PREFERRED_NAME(cregex_iterator)
_LIBCPP_PREFERRED_NAME(wcregex_iterator) _LIBCPP_IF_WIDE_CHARACTERS(_LIBCPP_PREFERRED_NAME(wcregex_iterator))
_LIBCPP_PREFERRED_NAME(sregex_iterator) _LIBCPP_PREFERRED_NAME(sregex_iterator)
_LIBCPP_PREFERRED_NAME(wsregex_iterator) _LIBCPP_IF_WIDE_CHARACTERS(_LIBCPP_PREFERRED_NAME(wsregex_iterator))
regex_iterator regex_iterator
{ {
public: public:
typedef basic_regex<_CharT, _Traits> regex_type; typedef basic_regex<_CharT, _Traits> regex_type;
typedef match_results<_BidirectionalIterator> value_type; typedef match_results<_BidirectionalIterator> value_type;
typedef ptrdiff_t difference_type; typedef ptrdiff_t difference_type;
typedef const value_type* pointer; typedef const value_type* pointer;
typedef const value_type& reference; typedef const value_type& reference;
▲ Show 20 Lines • Show All 101 Lines • ▼ Show 20 Lines
// regex_token_iterator // regex_token_iterator
template <class _BidirectionalIterator, template <class _BidirectionalIterator,
class _CharT = typename iterator_traits<_BidirectionalIterator>::value_type, class _CharT = typename iterator_traits<_BidirectionalIterator>::value_type,
class _Traits = regex_traits<_CharT> > class _Traits = regex_traits<_CharT> >
class _LIBCPP_TEMPLATE_VIS regex_token_iterator; class _LIBCPP_TEMPLATE_VIS regex_token_iterator;
typedef regex_token_iterator<const char*> cregex_token_iterator; typedef regex_token_iterator<const char*> cregex_token_iterator;
typedef regex_token_iterator<const wchar_t*> wcregex_token_iterator;
typedef regex_token_iterator<string::const_iterator> sregex_token_iterator; typedef regex_token_iterator<string::const_iterator> sregex_token_iterator;
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
typedef regex_token_iterator<const wchar_t*> wcregex_token_iterator;
typedef regex_token_iterator<wstring::const_iterator> wsregex_token_iterator; typedef regex_token_iterator<wstring::const_iterator> wsregex_token_iterator;
#endif
template <class _BidirectionalIterator, class _CharT, class _Traits> template <class _BidirectionalIterator, class _CharT, class _Traits>
class class
_LIBCPP_TEMPLATE_VIS _LIBCPP_TEMPLATE_VIS
_LIBCPP_PREFERRED_NAME(cregex_token_iterator) _LIBCPP_PREFERRED_NAME(cregex_token_iterator)
_LIBCPP_PREFERRED_NAME(wcregex_token_iterator) _LIBCPP_IF_WIDE_CHARACTERS(_LIBCPP_PREFERRED_NAME(wcregex_token_iterator))
_LIBCPP_PREFERRED_NAME(sregex_token_iterator) _LIBCPP_PREFERRED_NAME(sregex_token_iterator)
_LIBCPP_PREFERRED_NAME(wsregex_token_iterator) _LIBCPP_IF_WIDE_CHARACTERS(_LIBCPP_PREFERRED_NAME(wsregex_token_iterator))
regex_token_iterator regex_token_iterator
{ {
public: public:
typedef basic_regex<_CharT, _Traits> regex_type; typedef basic_regex<_CharT, _Traits> regex_type;
typedef sub_match<_BidirectionalIterator> value_type; typedef sub_match<_BidirectionalIterator> value_type;
typedef ptrdiff_t difference_type; typedef ptrdiff_t difference_type;
typedef const value_type* pointer; typedef const value_type* pointer;
typedef const value_type& reference; typedef const value_type& reference;
▲ Show 20 Lines • Show All 382 Lines • Show Last 20 Lines

libcxx/include/string

libcxx/include/string_view

libcxx/include/wchar.h

Show First 20 Lines • Show All 102 Lines • ▼ Show 20 Lines
size_t wcsrtombs(char* restrict dst, const wchar_t** restrict src, size_t len, size_t wcsrtombs(char* restrict dst, const wchar_t** restrict src, size_t len,
mbstate_t* restrict ps); mbstate_t* restrict ps);
*/ */
#include <__config> #include <__config>
#include <stddef.h> #include <stddef.h>
#if defined(_LIBCPP_HAS_NO_WIDE_CHARACTERS)
# error "The <wchar.h> header is not supported since libc++ has been configured with LIBCXX_ENABLE_WIDE_CHARACTERS disabled"
#endif
thakisUnsubmitted
Not Done
ReplyInline Actions

"""
I know it's not my job to judge, but these lines might lead to unnecessary problems:
I assume there's quite a few build scripts that look at this and say, "hey, I've got wchar.h, why not include it"
... this is not just an assumption. libc++ does the same thing with locale.h and ncurses's c++ example files greedily include it if they find it
"""

thakis: """ I know it's not my job to judge, but these lines might lead to unnecessary problems: I…
QuuxplusoneUnsubmitted
Not Done
ReplyInline Actions

+1 in that this is also inconsistent with how we treat #include <ranges> in pre-C++20 modes, and so on. For better or worse, the precedent is pretty consistently "when a header isn't supported, including it should be a no-op."

Quuxplusone: +1 in that this is also inconsistent with how we treat `#include <ranges>` in pre-C++20 modes…
MordanteUnsubmitted
Not Done
ReplyInline Actions

I know we discussed this for the incomplete ranges and format header and decided not to do an error.

However there are more CMake options that turn including a specific header in an error. For example when disabling _LIBCPP_HAS_NO_LOCALIZATION including locale.h will result in an error. I don't have a strong opinion on whether or not we should remove the #error in wchar.h, but if we remove it I think we should evaluate the other #errors in libc++.

Mordante: I know we discussed this for the incomplete ranges and format header and decided not to do an…
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header #pragma GCC system_header
#endif #endif
#ifdef __cplusplus #ifdef __cplusplus
#define __CORRECT_ISO_CPP_WCHAR_H_PROTO #define __CORRECT_ISO_CPP_WCHAR_H_PROTO
#endif #endif
▲ Show 20 Lines • Show All 64 Lines • Show Last 20 Lines

libcxx/include/wctype.h

libcxx/src/algorithm.cpp

libcxx/src/ios.instantiations.cpp

libcxx/src/iostream.cpp

libcxx/src/locale.cpp

Show All 12 Lines
#endif #endif
#include "algorithm" #include "algorithm"
#include "clocale" #include "clocale"
#include "codecvt" #include "codecvt"
#include "cstdio" #include "cstdio"
#include "cstdlib" #include "cstdlib"
#include "cstring" #include "cstring"
#include "cwctype"
#include "locale" #include "locale"
#include "string" #include "string"
#include "type_traits" #include "type_traits"
#include "typeinfo" #include "typeinfo"
#include "vector" #include "vector"
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
# include "cwctype"
#endif
#if defined(_LIBCPP_MSVCRT) #if defined(_LIBCPP_MSVCRT)
# define _CTYPE_DISABLE_MACROS # define _CTYPE_DISABLE_MACROS
#endif #endif
#if defined(_LIBCPP_MSVCRT) || defined(__MINGW32__) #if defined(_LIBCPP_MSVCRT) || defined(__MINGW32__)
# include "__support/win32/locale_win32.h" # include "__support/win32/locale_win32.h"
#elif !defined(__BIONIC__) && !defined(__NuttX__) #elif !defined(__BIONIC__) && !defined(__NuttX__)
# include <langinfo.h> # include <langinfo.h>
▲ Show 20 Lines • Show All 135 Lines • ▼ Show 20 Lines
locale::__imp::__imp(size_t refs) locale::__imp::__imp(size_t refs)
: facet(refs), : facet(refs),
facets_(N), facets_(N),
name_("C") name_("C")
{ {
facets_.clear(); facets_.clear();
install(&make<_VSTD::collate<char> >(1u)); install(&make<_VSTD::collate<char> >(1u));
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
install(&make<_VSTD::collate<wchar_t> >(1u)); install(&make<_VSTD::collate<wchar_t> >(1u));
#endif
install(&make<_VSTD::ctype<char> >(nullptr, false, 1u)); install(&make<_VSTD::ctype<char> >(nullptr, false, 1u));
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
install(&make<_VSTD::ctype<wchar_t> >(1u)); install(&make<_VSTD::ctype<wchar_t> >(1u));
#endif
install(&make<codecvt<char, char, mbstate_t> >(1u)); install(&make<codecvt<char, char, mbstate_t> >(1u));
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
install(&make<codecvt<wchar_t, char, mbstate_t> >(1u)); install(&make<codecvt<wchar_t, char, mbstate_t> >(1u));
#endif
_LIBCPP_SUPPRESS_DEPRECATED_PUSH _LIBCPP_SUPPRESS_DEPRECATED_PUSH
install(&make<codecvt<char16_t, char, mbstate_t> >(1u)); install(&make<codecvt<char16_t, char, mbstate_t> >(1u));
install(&make<codecvt<char32_t, char, mbstate_t> >(1u)); install(&make<codecvt<char32_t, char, mbstate_t> >(1u));
_LIBCPP_SUPPRESS_DEPRECATED_POP _LIBCPP_SUPPRESS_DEPRECATED_POP
#ifndef _LIBCPP_HAS_NO_CHAR8_T #ifndef _LIBCPP_HAS_NO_CHAR8_T
install(&make<codecvt<char16_t, char8_t, mbstate_t> >(1u)); install(&make<codecvt<char16_t, char8_t, mbstate_t> >(1u));
install(&make<codecvt<char32_t, char8_t, mbstate_t> >(1u)); install(&make<codecvt<char32_t, char8_t, mbstate_t> >(1u));
#endif #endif
install(&make<numpunct<char> >(1u)); install(&make<numpunct<char> >(1u));
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
install(&make<numpunct<wchar_t> >(1u)); install(&make<numpunct<wchar_t> >(1u));
#endif
install(&make<num_get<char> >(1u)); install(&make<num_get<char> >(1u));
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
install(&make<num_get<wchar_t> >(1u)); install(&make<num_get<wchar_t> >(1u));
#endif
install(&make<num_put<char> >(1u)); install(&make<num_put<char> >(1u));
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
install(&make<num_put<wchar_t> >(1u)); install(&make<num_put<wchar_t> >(1u));
#endif
install(&make<moneypunct<char, false> >(1u)); install(&make<moneypunct<char, false> >(1u));
install(&make<moneypunct<char, true> >(1u)); install(&make<moneypunct<char, true> >(1u));
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
install(&make<moneypunct<wchar_t, false> >(1u)); install(&make<moneypunct<wchar_t, false> >(1u));
install(&make<moneypunct<wchar_t, true> >(1u)); install(&make<moneypunct<wchar_t, true> >(1u));
#endif
install(&make<money_get<char> >(1u)); install(&make<money_get<char> >(1u));
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
install(&make<money_get<wchar_t> >(1u)); install(&make<money_get<wchar_t> >(1u));
#endif
install(&make<money_put<char> >(1u)); install(&make<money_put<char> >(1u));
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
install(&make<money_put<wchar_t> >(1u)); install(&make<money_put<wchar_t> >(1u));
#endif
install(&make<time_get<char> >(1u)); install(&make<time_get<char> >(1u));
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
install(&make<time_get<wchar_t> >(1u)); install(&make<time_get<wchar_t> >(1u));
#endif
install(&make<time_put<char> >(1u)); install(&make<time_put<char> >(1u));
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
install(&make<time_put<wchar_t> >(1u)); install(&make<time_put<wchar_t> >(1u));
#endif
install(&make<_VSTD::messages<char> >(1u)); install(&make<_VSTD::messages<char> >(1u));
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
install(&make<_VSTD::messages<wchar_t> >(1u)); install(&make<_VSTD::messages<wchar_t> >(1u));
#endif
} }
locale::__imp::__imp(const string& name, size_t refs) locale::__imp::__imp(const string& name, size_t refs)
: facet(refs), : facet(refs),
facets_(N), facets_(N),
name_(name) name_(name)
{ {
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_NO_EXCEPTIONS
try try
{ {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_NO_EXCEPTIONS
facets_ = locale::classic().__locale_->facets_; facets_ = locale::classic().__locale_->facets_;
for (unsigned i = 0; i < facets_.size(); ++i) for (unsigned i = 0; i < facets_.size(); ++i)
if (facets_[i]) if (facets_[i])
facets_[i]->__add_shared(); facets_[i]->__add_shared();
install(new collate_byname<char>(name_)); install(new collate_byname<char>(name_));
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
install(new collate_byname<wchar_t>(name_)); install(new collate_byname<wchar_t>(name_));
#endif
install(new ctype_byname<char>(name_)); install(new ctype_byname<char>(name_));
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
install(new ctype_byname<wchar_t>(name_)); install(new ctype_byname<wchar_t>(name_));
#endif
install(new codecvt_byname<char, char, mbstate_t>(name_)); install(new codecvt_byname<char, char, mbstate_t>(name_));
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
install(new codecvt_byname<wchar_t, char, mbstate_t>(name_)); install(new codecvt_byname<wchar_t, char, mbstate_t>(name_));
#endif
_LIBCPP_SUPPRESS_DEPRECATED_PUSH _LIBCPP_SUPPRESS_DEPRECATED_PUSH
install(new codecvt_byname<char16_t, char, mbstate_t>(name_)); install(new codecvt_byname<char16_t, char, mbstate_t>(name_));
install(new codecvt_byname<char32_t, char, mbstate_t>(name_)); install(new codecvt_byname<char32_t, char, mbstate_t>(name_));
_LIBCPP_SUPPRESS_DEPRECATED_POP _LIBCPP_SUPPRESS_DEPRECATED_POP
#ifndef _LIBCPP_HAS_NO_CHAR8_T #ifndef _LIBCPP_HAS_NO_CHAR8_T
install(new codecvt_byname<char16_t, char8_t, mbstate_t>(name_)); install(new codecvt_byname<char16_t, char8_t, mbstate_t>(name_));
install(new codecvt_byname<char32_t, char8_t, mbstate_t>(name_)); install(new codecvt_byname<char32_t, char8_t, mbstate_t>(name_));
#endif #endif
install(new numpunct_byname<char>(name_)); install(new numpunct_byname<char>(name_));
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
install(new numpunct_byname<wchar_t>(name_)); install(new numpunct_byname<wchar_t>(name_));
#endif
install(new moneypunct_byname<char, false>(name_)); install(new moneypunct_byname<char, false>(name_));
install(new moneypunct_byname<char, true>(name_)); install(new moneypunct_byname<char, true>(name_));
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
install(new moneypunct_byname<wchar_t, false>(name_)); install(new moneypunct_byname<wchar_t, false>(name_));
install(new moneypunct_byname<wchar_t, true>(name_)); install(new moneypunct_byname<wchar_t, true>(name_));
#endif
install(new time_get_byname<char>(name_)); install(new time_get_byname<char>(name_));
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
install(new time_get_byname<wchar_t>(name_)); install(new time_get_byname<wchar_t>(name_));
#endif
install(new time_put_byname<char>(name_)); install(new time_put_byname<char>(name_));
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
install(new time_put_byname<wchar_t>(name_)); install(new time_put_byname<wchar_t>(name_));
#endif
install(new messages_byname<char>(name_)); install(new messages_byname<char>(name_));
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
install(new messages_byname<wchar_t>(name_)); install(new messages_byname<wchar_t>(name_));
#endif
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
for (unsigned i = 0; i < facets_.size(); ++i) for (unsigned i = 0; i < facets_.size(); ++i)
if (facets_[i]) if (facets_[i])
facets_[i]->__release_shared(); facets_[i]->__release_shared();
throw; throw;
Show All 21 Lines for (unsigned i = 0; i < facets_.size(); ++i)
facets_[i]->__add_shared(); facets_[i]->__add_shared();
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_NO_EXCEPTIONS
try try
{ {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_NO_EXCEPTIONS
if (c & locale::collate) if (c & locale::collate)
{ {
install(new collate_byname<char>(name)); install(new collate_byname<char>(name));
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
install(new collate_byname<wchar_t>(name)); install(new collate_byname<wchar_t>(name));
#endif
} }
if (c & locale::ctype) if (c & locale::ctype)
{ {
install(new ctype_byname<char>(name)); install(new ctype_byname<char>(name));
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
install(new ctype_byname<wchar_t>(name)); install(new ctype_byname<wchar_t>(name));
#endif
install(new codecvt_byname<char, char, mbstate_t>(name)); install(new codecvt_byname<char, char, mbstate_t>(name));
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
install(new codecvt_byname<wchar_t, char, mbstate_t>(name)); install(new codecvt_byname<wchar_t, char, mbstate_t>(name));
#endif
_LIBCPP_SUPPRESS_DEPRECATED_PUSH _LIBCPP_SUPPRESS_DEPRECATED_PUSH
install(new codecvt_byname<char16_t, char, mbstate_t>(name)); install(new codecvt_byname<char16_t, char, mbstate_t>(name));
install(new codecvt_byname<char32_t, char, mbstate_t>(name)); install(new codecvt_byname<char32_t, char, mbstate_t>(name));
_LIBCPP_SUPPRESS_DEPRECATED_POP _LIBCPP_SUPPRESS_DEPRECATED_POP
#ifndef _LIBCPP_HAS_NO_CHAR8_T #ifndef _LIBCPP_HAS_NO_CHAR8_T
install(new codecvt_byname<char16_t, char8_t, mbstate_t>(name)); install(new codecvt_byname<char16_t, char8_t, mbstate_t>(name));
install(new codecvt_byname<char32_t, char8_t, mbstate_t>(name)); install(new codecvt_byname<char32_t, char8_t, mbstate_t>(name));
#endif #endif
} }
if (c & locale::monetary) if (c & locale::monetary)
{ {
install(new moneypunct_byname<char, false>(name)); install(new moneypunct_byname<char, false>(name));
install(new moneypunct_byname<char, true>(name)); install(new moneypunct_byname<char, true>(name));
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
install(new moneypunct_byname<wchar_t, false>(name)); install(new moneypunct_byname<wchar_t, false>(name));
install(new moneypunct_byname<wchar_t, true>(name)); install(new moneypunct_byname<wchar_t, true>(name));
#endif
} }
if (c & locale::numeric) if (c & locale::numeric)
{ {
install(new numpunct_byname<char>(name)); install(new numpunct_byname<char>(name));
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
install(new numpunct_byname<wchar_t>(name)); install(new numpunct_byname<wchar_t>(name));
#endif
} }
if (c & locale::time) if (c & locale::time)
{ {
install(new time_get_byname<char>(name)); install(new time_get_byname<char>(name));
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
install(new time_get_byname<wchar_t>(name)); install(new time_get_byname<wchar_t>(name));
#endif
install(new time_put_byname<char>(name)); install(new time_put_byname<char>(name));
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
install(new time_put_byname<wchar_t>(name)); install(new time_put_byname<wchar_t>(name));
#endif
} }
if (c & locale::messages) if (c & locale::messages)
{ {
install(new messages_byname<char>(name)); install(new messages_byname<char>(name));
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
install(new messages_byname<wchar_t>(name)); install(new messages_byname<wchar_t>(name));
#endif
} }
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
for (unsigned i = 0; i < facets_.size(); ++i) for (unsigned i = 0; i < facets_.size(); ++i)
if (facets_[i]) if (facets_[i])
facets_[i]->__release_shared(); facets_[i]->__release_shared();
Show All 21 Lines for (unsigned i = 0; i < facets_.size(); ++i)
facets_[i]->__add_shared(); facets_[i]->__add_shared();
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_NO_EXCEPTIONS
try try
{ {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_NO_EXCEPTIONS
if (c & locale::collate) if (c & locale::collate)
{ {
install_from<_VSTD::collate<char> >(one); install_from<_VSTD::collate<char> >(one);
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
install_from<_VSTD::collate<wchar_t> >(one); install_from<_VSTD::collate<wchar_t> >(one);
#endif
} }
if (c & locale::ctype) if (c & locale::ctype)
{ {
install_from<_VSTD::ctype<char> >(one); install_from<_VSTD::ctype<char> >(one);
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
install_from<_VSTD::ctype<wchar_t> >(one); install_from<_VSTD::ctype<wchar_t> >(one);
#endif
install_from<_VSTD::codecvt<char, char, mbstate_t> >(one); install_from<_VSTD::codecvt<char, char, mbstate_t> >(one);
_LIBCPP_SUPPRESS_DEPRECATED_PUSH _LIBCPP_SUPPRESS_DEPRECATED_PUSH
install_from<_VSTD::codecvt<char16_t, char, mbstate_t> >(one); install_from<_VSTD::codecvt<char16_t, char, mbstate_t> >(one);
install_from<_VSTD::codecvt<char32_t, char, mbstate_t> >(one); install_from<_VSTD::codecvt<char32_t, char, mbstate_t> >(one);
_LIBCPP_SUPPRESS_DEPRECATED_POP _LIBCPP_SUPPRESS_DEPRECATED_POP
#ifndef _LIBCPP_HAS_NO_CHAR8_T #ifndef _LIBCPP_HAS_NO_CHAR8_T
install_from<_VSTD::codecvt<char16_t, char8_t, mbstate_t> >(one); install_from<_VSTD::codecvt<char16_t, char8_t, mbstate_t> >(one);
install_from<_VSTD::codecvt<char32_t, char8_t, mbstate_t> >(one); install_from<_VSTD::codecvt<char32_t, char8_t, mbstate_t> >(one);
#endif #endif
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
install_from<_VSTD::codecvt<wchar_t, char, mbstate_t> >(one); install_from<_VSTD::codecvt<wchar_t, char, mbstate_t> >(one);
#endif
} }
if (c & locale::monetary) if (c & locale::monetary)
{ {
install_from<moneypunct<char, false> >(one); install_from<moneypunct<char, false> >(one);
install_from<moneypunct<char, true> >(one); install_from<moneypunct<char, true> >(one);
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
install_from<moneypunct<wchar_t, false> >(one); install_from<moneypunct<wchar_t, false> >(one);
install_from<moneypunct<wchar_t, true> >(one); install_from<moneypunct<wchar_t, true> >(one);
#endif
install_from<money_get<char> >(one); install_from<money_get<char> >(one);
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
install_from<money_get<wchar_t> >(one); install_from<money_get<wchar_t> >(one);
#endif
install_from<money_put<char> >(one); install_from<money_put<char> >(one);
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
install_from<money_put<wchar_t> >(one); install_from<money_put<wchar_t> >(one);
#endif
} }
if (c & locale::numeric) if (c & locale::numeric)
{ {
install_from<numpunct<char> >(one); install_from<numpunct<char> >(one);
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
install_from<numpunct<wchar_t> >(one); install_from<numpunct<wchar_t> >(one);
#endif
install_from<num_get<char> >(one); install_from<num_get<char> >(one);
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
install_from<num_get<wchar_t> >(one); install_from<num_get<wchar_t> >(one);
#endif
install_from<num_put<char> >(one); install_from<num_put<char> >(one);
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
install_from<num_put<wchar_t> >(one); install_from<num_put<wchar_t> >(one);
#endif
} }
if (c & locale::time) if (c & locale::time)
{ {
install_from<time_get<char> >(one); install_from<time_get<char> >(one);
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
install_from<time_get<wchar_t> >(one); install_from<time_get<wchar_t> >(one);
#endif
install_from<time_put<char> >(one); install_from<time_put<char> >(one);
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
install_from<time_put<wchar_t> >(one); install_from<time_put<wchar_t> >(one);
#endif
} }
if (c & locale::messages) if (c & locale::messages)
{ {
install_from<_VSTD::messages<char> >(one); install_from<_VSTD::messages<char> >(one);
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
install_from<_VSTD::messages<wchar_t> >(one); install_from<_VSTD::messages<wchar_t> >(one);
#endif
} }
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
for (unsigned i = 0; i < facets_.size(); ++i) for (unsigned i = 0; i < facets_.size(); ++i)
if (facets_[i]) if (facets_[i])
facets_[i]->__release_shared(); facets_[i]->__release_shared();
▲ Show 20 Lines • Show All 274 Lines • ▼ Show 20 Linescollate_byname<char>::do_transform(const char_type* lo, const char_type* hi) const
const string_type in(lo, hi); const string_type in(lo, hi);
string_type out(strxfrm_l(0, in.c_str(), 0, __l), char()); string_type out(strxfrm_l(0, in.c_str(), 0, __l), char());
strxfrm_l(const_cast<char*>(out.c_str()), in.c_str(), out.size()+1, __l); strxfrm_l(const_cast<char*>(out.c_str()), in.c_str(), out.size()+1, __l);
return out; return out;
} }
// template <> class collate_byname<wchar_t> // template <> class collate_byname<wchar_t>
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
collate_byname<wchar_t>::collate_byname(const char* n, size_t refs) collate_byname<wchar_t>::collate_byname(const char* n, size_t refs)
: collate<wchar_t>(refs), : collate<wchar_t>(refs),
__l(newlocale(LC_ALL_MASK, n, 0)) __l(newlocale(LC_ALL_MASK, n, 0))
{ {
if (__l == 0) if (__l == 0)
__throw_runtime_error("collate_byname<wchar_t>::collate_byname(size_t refs)" __throw_runtime_error("collate_byname<wchar_t>::collate_byname(size_t refs)"
" failed to construct for " + string(n)); " failed to construct for " + string(n));
} }
Show All 29 Lines
collate_byname<wchar_t>::string_type collate_byname<wchar_t>::string_type
collate_byname<wchar_t>::do_transform(const char_type* lo, const char_type* hi) const collate_byname<wchar_t>::do_transform(const char_type* lo, const char_type* hi) const
{ {
const string_type in(lo, hi); const string_type in(lo, hi);
string_type out(wcsxfrm_l(0, in.c_str(), 0, __l), wchar_t()); string_type out(wcsxfrm_l(0, in.c_str(), 0, __l), wchar_t());
wcsxfrm_l(const_cast<wchar_t*>(out.c_str()), in.c_str(), out.size()+1, __l); wcsxfrm_l(const_cast<wchar_t*>(out.c_str()), in.c_str(), out.size()+1, __l);
return out; return out;
} }
#endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
const ctype_base::mask ctype_base::space; const ctype_base::mask ctype_base::space;
const ctype_base::mask ctype_base::print; const ctype_base::mask ctype_base::print;
const ctype_base::mask ctype_base::cntrl; const ctype_base::mask ctype_base::cntrl;
const ctype_base::mask ctype_base::upper; const ctype_base::mask ctype_base::upper;
const ctype_base::mask ctype_base::lower; const ctype_base::mask ctype_base::lower;
const ctype_base::mask ctype_base::alpha; const ctype_base::mask ctype_base::alpha;
const ctype_base::mask ctype_base::digit; const ctype_base::mask ctype_base::digit;
const ctype_base::mask ctype_base::punct; const ctype_base::mask ctype_base::punct;
const ctype_base::mask ctype_base::xdigit; const ctype_base::mask ctype_base::xdigit;
const ctype_base::mask ctype_base::blank; const ctype_base::mask ctype_base::blank;
const ctype_base::mask ctype_base::alnum; const ctype_base::mask ctype_base::alnum;
const ctype_base::mask ctype_base::graph; const ctype_base::mask ctype_base::graph;
// template <> class ctype<wchar_t>; // template <> class ctype<wchar_t>;
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
locale::id ctype<wchar_t>::id; locale::id ctype<wchar_t>::id;
ctype<wchar_t>::~ctype() ctype<wchar_t>::~ctype()
{ {
} }
bool bool
ctype<wchar_t>::do_is(mask m, char_type c) const ctype<wchar_t>::do_is(mask m, char_type c) const
▲ Show 20 Lines • Show All 113 Lines • ▼ Show 20 Lines
{ {
for (; low != high; ++low, ++dest) for (; low != high; ++low, ++dest)
if (isascii(*low)) if (isascii(*low))
*dest = static_cast<char>(*low); *dest = static_cast<char>(*low);
else else
*dest = dfault; *dest = dfault;
return low; return low;
} }
#endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
// template <> class ctype<char>; // template <> class ctype<char>;
locale::id ctype<char>::id; locale::id ctype<char>::id;
ctype<char>::ctype(const mask* tab, bool del, size_t refs) ctype<char>::ctype(const mask* tab, bool del, size_t refs)
: locale::facet(refs), : locale::facet(refs),
__tab_(tab), __tab_(tab),
▲ Show 20 Lines • Show All 315 Lines • ▼ Show 20 Lines
{ {
for (; low != high; ++low) for (; low != high; ++low)
*low = static_cast<char>(tolower_l(static_cast<unsigned char>(*low), __l)); *low = static_cast<char>(tolower_l(static_cast<unsigned char>(*low), __l));
return low; return low;
} }
// template <> class ctype_byname<wchar_t> // template <> class ctype_byname<wchar_t>
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
ctype_byname<wchar_t>::ctype_byname(const char* name, size_t refs) ctype_byname<wchar_t>::ctype_byname(const char* name, size_t refs)
: ctype<wchar_t>(refs), : ctype<wchar_t>(refs),
__l(newlocale(LC_ALL_MASK, name, 0)) __l(newlocale(LC_ALL_MASK, name, 0))
{ {
if (__l == 0) if (__l == 0)
__throw_runtime_error("ctype_byname<wchar_t>::ctype_byname" __throw_runtime_error("ctype_byname<wchar_t>::ctype_byname"
" failed to construct for " + string(name)); " failed to construct for " + string(name));
} }
▲ Show 20 Lines • Show All 183 Lines • ▼ Show 20 Lines
{ {
for (; low != high; ++low, ++dest) for (; low != high; ++low, ++dest)
{ {
int r = __libcpp_wctob_l(*low, __l); int r = __libcpp_wctob_l(*low, __l);
*dest = r != static_cast<int>(WEOF) ? static_cast<char>(r) : dfault; *dest = r != static_cast<int>(WEOF) ? static_cast<char>(r) : dfault;
} }
return low; return low;
} }
#endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
// template <> class codecvt<char, char, mbstate_t> // template <> class codecvt<char, char, mbstate_t>
locale::id codecvt<char, char, mbstate_t>::id; locale::id codecvt<char, char, mbstate_t>::id;
codecvt<char, char, mbstate_t>::~codecvt() codecvt<char, char, mbstate_t>::~codecvt()
{ {
} }
▲ Show 20 Lines • Show All 48 Lines • ▼ Show 20 Lines
int int
codecvt<char, char, mbstate_t>::do_max_length() const noexcept codecvt<char, char, mbstate_t>::do_max_length() const noexcept
{ {
return 1; return 1;
} }
// template <> class codecvt<wchar_t, char, mbstate_t> // template <> class codecvt<wchar_t, char, mbstate_t>
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
locale::id codecvt<wchar_t, char, mbstate_t>::id; locale::id codecvt<wchar_t, char, mbstate_t>::id;
codecvt<wchar_t, char, mbstate_t>::codecvt(size_t refs) codecvt<wchar_t, char, mbstate_t>::codecvt(size_t refs)
: locale::facet(refs), : locale::facet(refs),
__l(_LIBCPP_GET_C_LOCALE) __l(_LIBCPP_GET_C_LOCALE)
{ {
} }
▲ Show 20 Lines • Show All 196 Lines • ▼ Show 20 Linescodecvt<wchar_t, char, mbstate_t>::do_length(state_type& st,
return nbytes; return nbytes;
} }
int int
codecvt<wchar_t, char, mbstate_t>::do_max_length() const noexcept codecvt<wchar_t, char, mbstate_t>::do_max_length() const noexcept
{ {
return __l == 0 ? 1 : static_cast<int>(__libcpp_mb_cur_max_l(__l)); return __l == 0 ? 1 : static_cast<int>(__libcpp_mb_cur_max_l(__l));
} }
#endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
// Valid UTF ranges // Valid UTF ranges
// UTF-32 UTF-16 UTF-8 # of code points // UTF-32 UTF-16 UTF-8 # of code points
// first second first second third fourth // first second first second third fourth
// 000000 - 00007F 0000 - 007F 00 - 7F 127 // 000000 - 00007F 0000 - 007F 00 - 7F 127
// 000080 - 0007FF 0080 - 07FF C2 - DF, 80 - BF 1920 // 000080 - 0007FF 0080 - 07FF C2 - DF, 80 - BF 1920
// 000800 - 000FFF 0800 - 0FFF E0 - E0, A0 - BF, 80 - BF 2048 // 000800 - 000FFF 0800 - 0FFF E0 - E0, A0 - BF, 80 - BF 2048
// 001000 - 00CFFF 1000 - CFFF E1 - EC, 80 - BF, 80 - BF 49152 // 001000 - 00CFFF 1000 - CFFF E1 - EC, 80 - BF, 80 - BF 49152
▲ Show 20 Lines • Show All 1,690 Lines • ▼ Show 20 Lines
{ {
return 4; return 4;
} }
#endif #endif
// __codecvt_utf8<wchar_t> // __codecvt_utf8<wchar_t>
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
__codecvt_utf8<wchar_t>::result __codecvt_utf8<wchar_t>::result
__codecvt_utf8<wchar_t>::do_out(state_type&, __codecvt_utf8<wchar_t>::do_out(state_type&,
const intern_type* frm, const intern_type* frm_end, const intern_type*& frm_nxt, const intern_type* frm, const intern_type* frm_end, const intern_type*& frm_nxt,
extern_type* to, extern_type* to_end, extern_type*& to_nxt) const extern_type* to, extern_type* to_end, extern_type*& to_nxt) const
{ {
#if defined(_LIBCPP_SHORT_WCHAR) #if defined(_LIBCPP_SHORT_WCHAR)
const uint16_t* _frm = reinterpret_cast<const uint16_t*>(frm); const uint16_t* _frm = reinterpret_cast<const uint16_t*>(frm);
const uint16_t* _frm_end = reinterpret_cast<const uint16_t*>(frm_end); const uint16_t* _frm_end = reinterpret_cast<const uint16_t*>(frm_end);
▲ Show 20 Lines • Show All 85 Lines • ▼ Show 20 Lines if (_Mode_ & consume_header)
return 6; return 6;
return 3; return 3;
#else #else
if (_Mode_ & consume_header) if (_Mode_ & consume_header)
return 7; return 7;
return 4; return 4;
#endif #endif
} }
#endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
// __codecvt_utf8<char16_t> // __codecvt_utf8<char16_t>
__codecvt_utf8<char16_t>::result __codecvt_utf8<char16_t>::result
__codecvt_utf8<char16_t>::do_out(state_type&, __codecvt_utf8<char16_t>::do_out(state_type&,
const intern_type* frm, const intern_type* frm_end, const intern_type*& frm_nxt, const intern_type* frm, const intern_type* frm_end, const intern_type*& frm_nxt,
extern_type* to, extern_type* to_end, extern_type*& to_nxt) const extern_type* to, extern_type* to_end, extern_type*& to_nxt) const
{ {
▲ Show 20 Lines • Show All 137 Lines • ▼ Show 20 Lines
{ {
if (_Mode_ & consume_header) if (_Mode_ & consume_header)
return 7; return 7;
return 4; return 4;
} }
// __codecvt_utf16<wchar_t, false> // __codecvt_utf16<wchar_t, false>
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
__codecvt_utf16<wchar_t, false>::result __codecvt_utf16<wchar_t, false>::result
__codecvt_utf16<wchar_t, false>::do_out(state_type&, __codecvt_utf16<wchar_t, false>::do_out(state_type&,
const intern_type* frm, const intern_type* frm_end, const intern_type*& frm_nxt, const intern_type* frm, const intern_type* frm_end, const intern_type*& frm_nxt,
extern_type* to, extern_type* to_end, extern_type*& to_nxt) const extern_type* to, extern_type* to_end, extern_type*& to_nxt) const
{ {
#if defined(_LIBCPP_SHORT_WCHAR) #if defined(_LIBCPP_SHORT_WCHAR)
const uint16_t* _frm = reinterpret_cast<const uint16_t*>(frm); const uint16_t* _frm = reinterpret_cast<const uint16_t*>(frm);
const uint16_t* _frm_end = reinterpret_cast<const uint16_t*>(frm_end); const uint16_t* _frm_end = reinterpret_cast<const uint16_t*>(frm_end);
▲ Show 20 Lines • Show All 189 Lines • ▼ Show 20 Lines if (_Mode_ & consume_header)
return 4; return 4;
return 2; return 2;
#else #else
if (_Mode_ & consume_header) if (_Mode_ & consume_header)
return 6; return 6;
return 4; return 4;
#endif #endif
} }
#endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
// __codecvt_utf16<char16_t, false> // __codecvt_utf16<char16_t, false>
__codecvt_utf16<char16_t, false>::result __codecvt_utf16<char16_t, false>::result
__codecvt_utf16<char16_t, false>::do_out(state_type&, __codecvt_utf16<char16_t, false>::do_out(state_type&,
const intern_type* frm, const intern_type* frm_end, const intern_type*& frm_nxt, const intern_type* frm, const intern_type* frm_end, const intern_type*& frm_nxt,
extern_type* to, extern_type* to_end, extern_type*& to_nxt) const extern_type* to, extern_type* to_end, extern_type*& to_nxt) const
{ {
▲ Show 20 Lines • Show All 287 Lines • ▼ Show 20 Lines
{ {
if (_Mode_ & consume_header) if (_Mode_ & consume_header)
return 6; return 6;
return 4; return 4;
} }
// __codecvt_utf8_utf16<wchar_t> // __codecvt_utf8_utf16<wchar_t>
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
__codecvt_utf8_utf16<wchar_t>::result __codecvt_utf8_utf16<wchar_t>::result
__codecvt_utf8_utf16<wchar_t>::do_out(state_type&, __codecvt_utf8_utf16<wchar_t>::do_out(state_type&,
const intern_type* frm, const intern_type* frm_end, const intern_type*& frm_nxt, const intern_type* frm, const intern_type* frm_end, const intern_type*& frm_nxt,
extern_type* to, extern_type* to_end, extern_type*& to_nxt) const extern_type* to, extern_type* to_end, extern_type*& to_nxt) const
{ {
#if defined(_LIBCPP_SHORT_WCHAR) #if defined(_LIBCPP_SHORT_WCHAR)
const uint16_t* _frm = reinterpret_cast<const uint16_t*>(frm); const uint16_t* _frm = reinterpret_cast<const uint16_t*>(frm);
const uint16_t* _frm_end = reinterpret_cast<const uint16_t*>(frm_end); const uint16_t* _frm_end = reinterpret_cast<const uint16_t*>(frm_end);
▲ Show 20 Lines • Show All 68 Lines • ▼ Show 20 Lines
int int
__codecvt_utf8_utf16<wchar_t>::do_max_length() const noexcept __codecvt_utf8_utf16<wchar_t>::do_max_length() const noexcept
{ {
if (_Mode_ & consume_header) if (_Mode_ & consume_header)
return 7; return 7;
return 4; return 4;
} }
#endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
// __codecvt_utf8_utf16<char16_t> // __codecvt_utf8_utf16<char16_t>
__codecvt_utf8_utf16<char16_t>::result __codecvt_utf8_utf16<char16_t>::result
__codecvt_utf8_utf16<char16_t>::do_out(state_type&, __codecvt_utf8_utf16<char16_t>::do_out(state_type&,
const intern_type* frm, const intern_type* frm_end, const intern_type*& frm_nxt, const intern_type* frm, const intern_type* frm_end, const intern_type*& frm_nxt,
extern_type* to, extern_type* to_end, extern_type*& to_nxt) const extern_type* to, extern_type* to_end, extern_type*& to_nxt) const
{ {
▲ Show 20 Lines • Show All 159 Lines • ▼ Show 20 Lines
} }
// __widen_from_utf8<32> // __widen_from_utf8<32>
__widen_from_utf8<32>::~__widen_from_utf8() __widen_from_utf8<32>::~__widen_from_utf8()
{ {
} }
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
static bool checked_string_to_wchar_convert(wchar_t& dest, static bool checked_string_to_wchar_convert(wchar_t& dest,
const char* ptr, const char* ptr,
locale_t loc) { locale_t loc) {
if (*ptr == '\0') if (*ptr == '\0')
return false; return false;
mbstate_t mb = {}; mbstate_t mb = {};
wchar_t out; wchar_t out;
size_t ret = __libcpp_mbrtowc_l(&out, ptr, strlen(ptr), &mb, loc); size_t ret = __libcpp_mbrtowc_l(&out, ptr, strlen(ptr), &mb, loc);
if (ret == static_cast<size_t>(-1) || ret == static_cast<size_t>(-2)) { if (ret == static_cast<size_t>(-1) || ret == static_cast<size_t>(-2)) {
return false; return false;
} }
dest = out; dest = out;
return true; return true;
} }
#endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
static bool checked_string_to_char_convert(char& dest, static bool checked_string_to_char_convert(char& dest,
const char* ptr, const char* ptr,
locale_t __loc) { locale_t __loc) {
if (*ptr == '\0') if (*ptr == '\0')
return false; return false;
if (!ptr[1]) { if (!ptr[1]) {
dest = *ptr; dest = *ptr;
return true; return true;
} }
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
ldionneAuthorUnsubmitted
Done
ReplyInline Actions

Calling this out too, I'm not entirely sure how to handle this properly when wchar_t isn't supported.

ldionne: Calling this out too, I'm not entirely sure how to handle this properly when `wchar_t` isn't…
// First convert the MBS into a wide char then attempt to narrow it using // First convert the MBS into a wide char then attempt to narrow it using
// wctob_l. // wctob_l.
wchar_t wout; wchar_t wout;
if (!checked_string_to_wchar_convert(wout, ptr, __loc)) if (!checked_string_to_wchar_convert(wout, ptr, __loc))
return false; return false;
int res; int res;
if ((res = __libcpp_wctob_l(wout, __loc)) != char_traits<char>::eof()) { if ((res = __libcpp_wctob_l(wout, __loc)) != char_traits<char>::eof()) {
dest = res; dest = res;
return true; return true;
} }
// FIXME: Work around specific multibyte sequences that we can reasonably // FIXME: Work around specific multibyte sequences that we can reasonably
// translate into a different single byte. // translate into a different single byte.
switch (wout) { switch (wout) {
case L'\u202F': // narrow non-breaking space case L'\u202F': // narrow non-breaking space
case L'\u00A0': // non-breaking space case L'\u00A0': // non-breaking space
dest = ' '; dest = ' ';
return true; return true;
default: default:
return false; return false;
} }
#else // _LIBCPP_HAS_NO_WIDE_CHARACTERS
MordanteUnsubmitted
Done
ReplyInline Actions
return false;
}
+ #else // _LIBCPP_HAS_NO_WIDE_CHARACTERS
+ return false;
#endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
_LIBCPP_UNREACHABLE();

I we should return false instead of reaching _LIBCPP_UNREACHABLE();.

When I understand the code correctly this is only an issue when the supplied "string" contains more than one character. This basically means numpunct's decimal_point or thousands_sep isn't a single character. I think it would suffice when adding this return and handle the returned false in the callers.

When vendors report that this doesn't work properly we can discuss with them what a better solution would be, for example using a lookup table to translate their "string" to a char. For now that seems over engineering.

Mordante: I we should `return false` instead of reaching `_LIBCPP_UNREACHABLE();`. When I understand the…
return false;
#endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
_LIBCPP_UNREACHABLE(); _LIBCPP_UNREACHABLE();
} }
// numpunct<char> && numpunct<wchar_t> // numpunct<char> && numpunct<wchar_t>
locale::id numpunct< char >::id; locale::id numpunct< char >::id;
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
locale::id numpunct<wchar_t>::id; locale::id numpunct<wchar_t>::id;
#endif
numpunct<char>::numpunct(size_t refs) numpunct<char>::numpunct(size_t refs)
: locale::facet(refs), : locale::facet(refs),
__decimal_point_('.'), __decimal_point_('.'),
__thousands_sep_(',') __thousands_sep_(',')
{ {
} }
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
numpunct<wchar_t>::numpunct(size_t refs) numpunct<wchar_t>::numpunct(size_t refs)
: locale::facet(refs), : locale::facet(refs),
__decimal_point_(L'.'), __decimal_point_(L'.'),
__thousands_sep_(L',') __thousands_sep_(L',')
{ {
} }
#endif
numpunct<char>::~numpunct() numpunct<char>::~numpunct()
{ {
} }
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
numpunct<wchar_t>::~numpunct() numpunct<wchar_t>::~numpunct()
{ {
} }
#endif
char numpunct< char >::do_decimal_point() const {return __decimal_point_;} char numpunct< char >::do_decimal_point() const {return __decimal_point_;}
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
wchar_t numpunct<wchar_t>::do_decimal_point() const {return __decimal_point_;} wchar_t numpunct<wchar_t>::do_decimal_point() const {return __decimal_point_;}
#endif
char numpunct< char >::do_thousands_sep() const {return __thousands_sep_;} char numpunct< char >::do_thousands_sep() const {return __thousands_sep_;}
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
wchar_t numpunct<wchar_t>::do_thousands_sep() const {return __thousands_sep_;} wchar_t numpunct<wchar_t>::do_thousands_sep() const {return __thousands_sep_;}
#endif
string numpunct< char >::do_grouping() const {return __grouping_;} string numpunct< char >::do_grouping() const {return __grouping_;}
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
string numpunct<wchar_t>::do_grouping() const {return __grouping_;} string numpunct<wchar_t>::do_grouping() const {return __grouping_;}
#endif
string numpunct< char >::do_truename() const {return "true";} string numpunct< char >::do_truename() const {return "true";}
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
wstring numpunct<wchar_t>::do_truename() const {return L"true";} wstring numpunct<wchar_t>::do_truename() const {return L"true";}
#endif
string numpunct< char >::do_falsename() const {return "false";} string numpunct< char >::do_falsename() const {return "false";}
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
wstring numpunct<wchar_t>::do_falsename() const {return L"false";} wstring numpunct<wchar_t>::do_falsename() const {return L"false";}
#endif
// numpunct_byname<char> // numpunct_byname<char>
numpunct_byname<char>::numpunct_byname(const char* nm, size_t refs) numpunct_byname<char>::numpunct_byname(const char* nm, size_t refs)
: numpunct<char>(refs) : numpunct<char>(refs)
{ {
__init(nm); __init(nm);
} }
numpunct_byname<char>::numpunct_byname(const string& nm, size_t refs) numpunct_byname<char>::numpunct_byname(const string& nm, size_t refs)
: numpunct<char>(refs) : numpunct<char>(refs)
{ {
__init(nm.c_str()); __init(nm.c_str());
} }
numpunct_byname<char>::~numpunct_byname() numpunct_byname<char>::~numpunct_byname()
{ {
} }
void void
numpunct_byname<char>::__init(const char* nm) numpunct_byname<char>::__init(const char* nm)
{ {
typedef numpunct<char> base;
if (strcmp(nm, "C") != 0) if (strcmp(nm, "C") != 0)
{ {
__libcpp_unique_locale loc(nm); __libcpp_unique_locale loc(nm);
if (!loc) if (!loc)
__throw_runtime_error("numpunct_byname<char>::numpunct_byname" __throw_runtime_error("numpunct_byname<char>::numpunct_byname"
" failed to construct for " + string(nm)); " failed to construct for " + string(nm));
lconv* lc = __libcpp_localeconv_l(loc.get()); lconv* lc = __libcpp_localeconv_l(loc.get());
checked_string_to_char_convert(__decimal_point_, lc->decimal_point, if (!checked_string_to_char_convert(__decimal_point_, lc->decimal_point,
MordanteUnsubmitted
Done
ReplyInline Actions

I think we should validate the return value here and two lines below.
Something like done in moneypunct_byname<char, false>

if (!checked_string_to_char_convert(__decimal_point_,
                                    lc->mon_decimal_point,
                                    loc.get()))
  __decimal_point_ = base::do_decimal_point();
Mordante: I think we should validate the return value here and two lines below. Something like done in…
ldionneAuthorUnsubmitted
Done
ReplyInline Actions

Thanks, honestly <locale> is gibberish to me.

ldionne: Thanks, honestly `<locale>` is gibberish to me.
loc.get()); loc.get()))
checked_string_to_char_convert(__thousands_sep_, lc->thousands_sep, __decimal_point_ = base::do_decimal_point();
loc.get()); if (!checked_string_to_char_convert(__thousands_sep_, lc->thousands_sep,
loc.get()))
__thousands_sep_ = base::do_thousands_sep();
__grouping_ = lc->grouping; __grouping_ = lc->grouping;
// localization for truename and falsename is not available // localization for truename and falsename is not available
} }
} }
// numpunct_byname<wchar_t> // numpunct_byname<wchar_t>
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
numpunct_byname<wchar_t>::numpunct_byname(const char* nm, size_t refs) numpunct_byname<wchar_t>::numpunct_byname(const char* nm, size_t refs)
: numpunct<wchar_t>(refs) : numpunct<wchar_t>(refs)
{ {
__init(nm); __init(nm);
} }
numpunct_byname<wchar_t>::numpunct_byname(const string& nm, size_t refs) numpunct_byname<wchar_t>::numpunct_byname(const string& nm, size_t refs)
: numpunct<wchar_t>(refs) : numpunct<wchar_t>(refs)
Show All 19 Lines if (strcmp(nm, "C") != 0)
checked_string_to_wchar_convert(__decimal_point_, lc->decimal_point, checked_string_to_wchar_convert(__decimal_point_, lc->decimal_point,
loc.get()); loc.get());
checked_string_to_wchar_convert(__thousands_sep_, lc->thousands_sep, checked_string_to_wchar_convert(__thousands_sep_, lc->thousands_sep,
loc.get()); loc.get());
__grouping_ = lc->grouping; __grouping_ = lc->grouping;
// localization for truename and falsename is not available // localization for truename and falsename is not available
} }
} }
#endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
// num_get helpers // num_get helpers
int int
__num_get_base::__get_base(ios_base& iob) __num_get_base::__get_base(ios_base& iob)
{ {
ios_base::fmtflags __basefield = iob.flags() & ios_base::basefield; ios_base::fmtflags __basefield = iob.flags() & ios_base::basefield;
if (__basefield == ios_base::oct) if (__basefield == ios_base::oct)
▲ Show 20 Lines • Show All 159 Lines • ▼ Show 20 Linesinit_weeks()
weeks[9] = "Tue"; weeks[9] = "Tue";
weeks[10] = "Wed"; weeks[10] = "Wed";
weeks[11] = "Thu"; weeks[11] = "Thu";
weeks[12] = "Fri"; weeks[12] = "Fri";
weeks[13] = "Sat"; weeks[13] = "Sat";
return weeks; return weeks;
} }
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
static static
wstring* wstring*
init_wweeks() init_wweeks()
{ {
static wstring weeks[14]; static wstring weeks[14];
weeks[0] = L"Sunday"; weeks[0] = L"Sunday";
weeks[1] = L"Monday"; weeks[1] = L"Monday";
weeks[2] = L"Tuesday"; weeks[2] = L"Tuesday";
weeks[3] = L"Wednesday"; weeks[3] = L"Wednesday";
weeks[4] = L"Thursday"; weeks[4] = L"Thursday";
weeks[5] = L"Friday"; weeks[5] = L"Friday";
weeks[6] = L"Saturday"; weeks[6] = L"Saturday";
weeks[7] = L"Sun"; weeks[7] = L"Sun";
weeks[8] = L"Mon"; weeks[8] = L"Mon";
weeks[9] = L"Tue"; weeks[9] = L"Tue";
weeks[10] = L"Wed"; weeks[10] = L"Wed";
weeks[11] = L"Thu"; weeks[11] = L"Thu";
weeks[12] = L"Fri"; weeks[12] = L"Fri";
weeks[13] = L"Sat"; weeks[13] = L"Sat";
return weeks; return weeks;
} }
#endif
template <> template <>
const string* const string*
__time_get_c_storage<char>::__weeks() const __time_get_c_storage<char>::__weeks() const
{ {
static const string* weeks = init_weeks(); static const string* weeks = init_weeks();
return weeks; return weeks;
} }
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
template <> template <>
const wstring* const wstring*
__time_get_c_storage<wchar_t>::__weeks() const __time_get_c_storage<wchar_t>::__weeks() const
{ {
static const wstring* weeks = init_wweeks(); static const wstring* weeks = init_wweeks();
return weeks; return weeks;
} }
#endif
static static
string* string*
init_months() init_months()
{ {
static string months[24]; static string months[24];
months[0] = "January"; months[0] = "January";
months[1] = "February"; months[1] = "February";
Show All 17 Linesinit_months()
months[19] = "Aug"; months[19] = "Aug";
months[20] = "Sep"; months[20] = "Sep";
months[21] = "Oct"; months[21] = "Oct";
months[22] = "Nov"; months[22] = "Nov";
months[23] = "Dec"; months[23] = "Dec";
return months; return months;
} }
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
static static
wstring* wstring*
init_wmonths() init_wmonths()
{ {
static wstring months[24]; static wstring months[24];
months[0] = L"January"; months[0] = L"January";
months[1] = L"February"; months[1] = L"February";
months[2] = L"March"; months[2] = L"March";
Show All 15 Linesinit_wmonths()
months[18] = L"Jul"; months[18] = L"Jul";
months[19] = L"Aug"; months[19] = L"Aug";
months[20] = L"Sep"; months[20] = L"Sep";
months[21] = L"Oct"; months[21] = L"Oct";
months[22] = L"Nov"; months[22] = L"Nov";
months[23] = L"Dec"; months[23] = L"Dec";
return months; return months;
} }
#endif
template <> template <>
const string* const string*
__time_get_c_storage<char>::__months() const __time_get_c_storage<char>::__months() const
{ {
static const string* months = init_months(); static const string* months = init_months();
return months; return months;
} }
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
template <> template <>
const wstring* const wstring*
__time_get_c_storage<wchar_t>::__months() const __time_get_c_storage<wchar_t>::__months() const
{ {
static const wstring* months = init_wmonths(); static const wstring* months = init_wmonths();
return months; return months;
} }
#endif
static static
string* string*
init_am_pm() init_am_pm()
{ {
static string am_pm[2]; static string am_pm[2];
am_pm[0] = "AM"; am_pm[0] = "AM";
am_pm[1] = "PM"; am_pm[1] = "PM";
return am_pm; return am_pm;
} }
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
static static
wstring* wstring*
init_wam_pm() init_wam_pm()
{ {
static wstring am_pm[2]; static wstring am_pm[2];
am_pm[0] = L"AM"; am_pm[0] = L"AM";
am_pm[1] = L"PM"; am_pm[1] = L"PM";
return am_pm; return am_pm;
} }
#endif
template <> template <>
const string* const string*
__time_get_c_storage<char>::__am_pm() const __time_get_c_storage<char>::__am_pm() const
{ {
static const string* am_pm = init_am_pm(); static const string* am_pm = init_am_pm();
return am_pm; return am_pm;
} }
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
template <> template <>
const wstring* const wstring*
__time_get_c_storage<wchar_t>::__am_pm() const __time_get_c_storage<wchar_t>::__am_pm() const
{ {
static const wstring* am_pm = init_wam_pm(); static const wstring* am_pm = init_wam_pm();
return am_pm; return am_pm;
} }
#endif
template <> template <>
const string& const string&
__time_get_c_storage<char>::__x() const __time_get_c_storage<char>::__x() const
{ {
static string s("%m/%d/%y"); static string s("%m/%d/%y");
return s; return s;
} }
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
template <> template <>
const wstring& const wstring&
__time_get_c_storage<wchar_t>::__x() const __time_get_c_storage<wchar_t>::__x() const
{ {
static wstring s(L"%m/%d/%y"); static wstring s(L"%m/%d/%y");
return s; return s;
} }
#endif
template <> template <>
const string& const string&
__time_get_c_storage<char>::__X() const __time_get_c_storage<char>::__X() const
{ {
static string s("%H:%M:%S"); static string s("%H:%M:%S");
return s; return s;
} }
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
template <> template <>
const wstring& const wstring&
__time_get_c_storage<wchar_t>::__X() const __time_get_c_storage<wchar_t>::__X() const
{ {
static wstring s(L"%H:%M:%S"); static wstring s(L"%H:%M:%S");
return s; return s;
} }
#endif
template <> template <>
const string& const string&
__time_get_c_storage<char>::__c() const __time_get_c_storage<char>::__c() const
{ {
static string s("%a %b %d %H:%M:%S %Y"); static string s("%a %b %d %H:%M:%S %Y");
return s; return s;
} }
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
template <> template <>
const wstring& const wstring&
__time_get_c_storage<wchar_t>::__c() const __time_get_c_storage<wchar_t>::__c() const
{ {
static wstring s(L"%a %b %d %H:%M:%S %Y"); static wstring s(L"%a %b %d %H:%M:%S %Y");
return s; return s;
} }
#endif
template <> template <>
const string& const string&
__time_get_c_storage<char>::__r() const __time_get_c_storage<char>::__r() const
{ {
static string s("%I:%M:%S %p"); static string s("%I:%M:%S %p");
return s; return s;
} }
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
template <> template <>
const wstring& const wstring&
__time_get_c_storage<wchar_t>::__r() const __time_get_c_storage<wchar_t>::__r() const
{ {
static wstring s(L"%I:%M:%S %p"); static wstring s(L"%I:%M:%S %p");
return s; return s;
} }
#endif
// time_get_byname // time_get_byname
__time_get::__time_get(const char* nm) __time_get::__time_get(const char* nm)
: __loc_(newlocale(LC_ALL_MASK, nm, 0)) : __loc_(newlocale(LC_ALL_MASK, nm, 0))
{ {
if (__loc_ == 0) if (__loc_ == 0)
__throw_runtime_error("time_get_byname" __throw_runtime_error("time_get_byname"
▲ Show 20 Lines • Show All 162 Lines • ▼ Show 20 Lines__time_get_storage<char>::__analyze(char fmt, const ctype<char>& ct)
} }
return result; return result;
} }
#if defined(__clang__) #if defined(__clang__)
#pragma clang diagnostic ignored "-Wmissing-braces" #pragma clang diagnostic ignored "-Wmissing-braces"
#endif #endif
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
template <> template <>
wstring wstring
__time_get_storage<wchar_t>::__analyze(char fmt, const ctype<wchar_t>& ct) __time_get_storage<wchar_t>::__analyze(char fmt, const ctype<wchar_t>& ct)
{ {
tm t = {0}; tm t = {0};
t.tm_sec = 59; t.tm_sec = 59;
t.tm_min = 55; t.tm_min = 55;
t.tm_hour = 23; t.tm_hour = 23;
▲ Show 20 Lines • Show All 133 Lines • ▼ Show 20 Lines while (wbb != wbe)
++wbb; ++wbb;
continue; continue;
} }
result.push_back(*wbb); result.push_back(*wbb);
++wbb; ++wbb;
} }
return result; return result;
} }
#endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
template <> template <>
void void
__time_get_storage<char>::init(const ctype<char>& ct) __time_get_storage<char>::init(const ctype<char>& ct)
{ {
tm t = {0}; tm t = {0};
char buf[100]; char buf[100];
// __weeks_ // __weeks_
Show All 22 Lines__time_get_storage<char>::init(const ctype<char>& ct)
strftime_l(buf, countof(buf), "%p", &t, __loc_); strftime_l(buf, countof(buf), "%p", &t, __loc_);
__am_pm_[1] = buf; __am_pm_[1] = buf;
__c_ = __analyze('c', ct); __c_ = __analyze('c', ct);
__r_ = __analyze('r', ct); __r_ = __analyze('r', ct);
__x_ = __analyze('x', ct); __x_ = __analyze('x', ct);
__X_ = __analyze('X', ct); __X_ = __analyze('X', ct);
} }
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
template <> template <>
void void
__time_get_storage<wchar_t>::init(const ctype<wchar_t>& ct) __time_get_storage<wchar_t>::init(const ctype<wchar_t>& ct)
{ {
tm t = {0}; tm t = {0};
char buf[100]; char buf[100];
wchar_t wbuf[100]; wchar_t wbuf[100];
wchar_t* wbe; wchar_t* wbe;
▲ Show 20 Lines • Show All 59 Lines • ▼ Show 20 Lines if (j == size_t(-1))
__throw_runtime_error("locale not supported"); __throw_runtime_error("locale not supported");
wbe = wbuf + j; wbe = wbuf + j;
__am_pm_[1].assign(wbuf, wbe); __am_pm_[1].assign(wbuf, wbe);
__c_ = __analyze('c', ct); __c_ = __analyze('c', ct);
__r_ = __analyze('r', ct); __r_ = __analyze('r', ct);
__x_ = __analyze('x', ct); __x_ = __analyze('x', ct);
__X_ = __analyze('X', ct); __X_ = __analyze('X', ct);
} }
#endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
template <class CharT> template <class CharT>
struct _LIBCPP_HIDDEN __time_get_temp struct _LIBCPP_HIDDEN __time_get_temp
: public ctype_byname<CharT> : public ctype_byname<CharT>
{ {
explicit __time_get_temp(const char* nm) explicit __time_get_temp(const char* nm)
: ctype_byname<CharT>(nm, 1) {} : ctype_byname<CharT>(nm, 1) {}
explicit __time_get_temp(const string& nm) explicit __time_get_temp(const string& nm)
Show All 11 Lines
template <> template <>
__time_get_storage<char>::__time_get_storage(const string& __nm) __time_get_storage<char>::__time_get_storage(const string& __nm)
: __time_get(__nm) : __time_get(__nm)
{ {
const __time_get_temp<char> ct(__nm); const __time_get_temp<char> ct(__nm);
init(ct); init(ct);
} }
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
template <> template <>
__time_get_storage<wchar_t>::__time_get_storage(const char* __nm) __time_get_storage<wchar_t>::__time_get_storage(const char* __nm)
: __time_get(__nm) : __time_get(__nm)
{ {
const __time_get_temp<wchar_t> ct(__nm); const __time_get_temp<wchar_t> ct(__nm);
init(ct); init(ct);
} }
template <> template <>
__time_get_storage<wchar_t>::__time_get_storage(const string& __nm) __time_get_storage<wchar_t>::__time_get_storage(const string& __nm)
: __time_get(__nm) : __time_get(__nm)
{ {
const __time_get_temp<wchar_t> ct(__nm); const __time_get_temp<wchar_t> ct(__nm);
init(ct); init(ct);
} }
#endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
template <> template <>
time_base::dateorder time_base::dateorder
__time_get_storage<char>::__do_date_order() const __time_get_storage<char>::__do_date_order() const
{ {
unsigned i; unsigned i;
for (i = 0; i < __x_.size(); ++i) for (i = 0; i < __x_.size(); ++i)
if (__x_[i] == '%') if (__x_[i] == '%')
▲ Show 20 Lines • Show All 72 Lines • ▼ Show 20 Lines case 'd':
return time_base::dmy; return time_base::dmy;
break; break;
} }
break; break;
} }
return time_base::no_order; return time_base::no_order;
} }
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
template <> template <>
time_base::dateorder time_base::dateorder
__time_get_storage<wchar_t>::__do_date_order() const __time_get_storage<wchar_t>::__do_date_order() const
{ {
unsigned i; unsigned i;
for (i = 0; i < __x_.size(); ++i) for (i = 0; i < __x_.size(); ++i)
if (__x_[i] == L'%') if (__x_[i] == L'%')
break; break;
▲ Show 20 Lines • Show All 70 Lines • ▼ Show 20 Lines case L'd':
if (__x_[i] == L'y' || __x_[i] == L'Y') if (__x_[i] == L'y' || __x_[i] == L'Y')
return time_base::dmy; return time_base::dmy;
break; break;
} }
break; break;
} }
return time_base::no_order; return time_base::no_order;
} }
#endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
// time_put // time_put
__time_put::__time_put(const char* nm) __time_put::__time_put(const char* nm)
: __loc_(newlocale(LC_ALL_MASK, nm, 0)) : __loc_(newlocale(LC_ALL_MASK, nm, 0))
{ {
if (__loc_ == 0) if (__loc_ == 0)
__throw_runtime_error("time_put_byname" __throw_runtime_error("time_put_byname"
Show All 20 Lines
{ {
char fmt[] = {'%', __fmt, __mod, 0}; char fmt[] = {'%', __fmt, __mod, 0};
if (__mod != 0) if (__mod != 0)
swap(fmt[1], fmt[2]); swap(fmt[1], fmt[2]);
size_t n = strftime_l(__nb, countof(__nb, __ne), fmt, __tm, __loc_); size_t n = strftime_l(__nb, countof(__nb, __ne), fmt, __tm, __loc_);
__ne = __nb + n; __ne = __nb + n;
} }
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
void void
__time_put::__do_put(wchar_t* __wb, wchar_t*& __we, const tm* __tm, __time_put::__do_put(wchar_t* __wb, wchar_t*& __we, const tm* __tm,
char __fmt, char __mod) const char __fmt, char __mod) const
{ {
char __nar[100]; char __nar[100];
char* __ne = __nar + 100; char* __ne = __nar + 100;
__do_put(__nar, __ne, __tm, __fmt, __mod); __do_put(__nar, __ne, __tm, __fmt, __mod);
mbstate_t mb = {0}; mbstate_t mb = {0};
const char* __nb = __nar; const char* __nb = __nar;
size_t j = __libcpp_mbsrtowcs_l(__wb, &__nb, countof(__wb, __we), &mb, __loc_); size_t j = __libcpp_mbsrtowcs_l(__wb, &__nb, countof(__wb, __we), &mb, __loc_);
if (j == size_t(-1)) if (j == size_t(-1))
__throw_runtime_error("locale not supported"); __throw_runtime_error("locale not supported");
__we = __wb + j; __we = __wb + j;
} }
#endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
// moneypunct_byname // moneypunct_byname
template <class charT> template <class charT>
static static
void void
__init_pat(money_base::pattern& pat, basic_string<charT>& __curr_symbol_, __init_pat(money_base::pattern& pat, basic_string<charT>& __curr_symbol_,
bool intl, char cs_precedes, char sep_by_space, char sign_posn, bool intl, char cs_precedes, char sep_by_space, char sign_posn,
▲ Show 20 Lines • Show All 463 Lines • ▼ Show 20 Lines __init_pat(__pos_format_, __dummy_curr_symbol, true,
lc->int_p_cs_precedes, lc->int_p_sep_by_space, lc->int_p_cs_precedes, lc->int_p_sep_by_space,
lc->int_p_sign_posn, ' '); lc->int_p_sign_posn, ' ');
__init_pat(__neg_format_, __curr_symbol_, true, __init_pat(__neg_format_, __curr_symbol_, true,
lc->int_n_cs_precedes, lc->int_n_sep_by_space, lc->int_n_cs_precedes, lc->int_n_sep_by_space,
lc->int_n_sign_posn, ' '); lc->int_n_sign_posn, ' ');
#endif // !_LIBCPP_MSVCRT #endif // !_LIBCPP_MSVCRT
} }
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
template<> template<>
void void
moneypunct_byname<wchar_t, false>::init(const char* nm) moneypunct_byname<wchar_t, false>::init(const char* nm)
{ {
typedef moneypunct<wchar_t, false> base; typedef moneypunct<wchar_t, false> base;
__libcpp_unique_locale loc(nm); __libcpp_unique_locale loc(nm);
if (!loc) if (!loc)
__throw_runtime_error("moneypunct_byname" __throw_runtime_error("moneypunct_byname"
▲ Show 20 Lines • Show All 131 Lines • ▼ Show 20 Lines#else // _LIBCPP_MSVCRT
__init_pat(__pos_format_, __dummy_curr_symbol, true, __init_pat(__pos_format_, __dummy_curr_symbol, true,
lc->int_p_cs_precedes, lc->int_p_sep_by_space, lc->int_p_cs_precedes, lc->int_p_sep_by_space,
lc->int_p_sign_posn, L' '); lc->int_p_sign_posn, L' ');
__init_pat(__neg_format_, __curr_symbol_, true, __init_pat(__neg_format_, __curr_symbol_, true,
lc->int_n_cs_precedes, lc->int_n_sep_by_space, lc->int_n_cs_precedes, lc->int_n_sep_by_space,
lc->int_n_sign_posn, L' '); lc->int_n_sign_posn, L' ');
#endif // !_LIBCPP_MSVCRT #endif // !_LIBCPP_MSVCRT
} }
#endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
void __do_nothing(void*) {} void __do_nothing(void*) {}
void __throw_runtime_error(const char* msg) void __throw_runtime_error(const char* msg)
{ {
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_NO_EXCEPTIONS
throw runtime_error(msg); throw runtime_error(msg);
#else #else
(void)msg; (void)msg;
_VSTD::abort(); _VSTD::abort();
#endif #endif
} }
template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS collate<char>; template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS collate<char>;
template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS collate<wchar_t>; _LIBCPP_IF_WIDE_CHARACTERS(template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS collate<wchar_t>;)
template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS num_get<char>; template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS num_get<char>;
template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS num_get<wchar_t>; _LIBCPP_IF_WIDE_CHARACTERS(template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS num_get<wchar_t>;)
template struct _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS __num_get<char>; template struct _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS __num_get<char>;
template struct _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS __num_get<wchar_t>; _LIBCPP_IF_WIDE_CHARACTERS(template struct _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS __num_get<wchar_t>;)
template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS num_put<char>; template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS num_put<char>;
template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS num_put<wchar_t>; _LIBCPP_IF_WIDE_CHARACTERS(template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS num_put<wchar_t>;)
template struct _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS __num_put<char>; template struct _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS __num_put<char>;
template struct _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS __num_put<wchar_t>; _LIBCPP_IF_WIDE_CHARACTERS(template struct _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS __num_put<wchar_t>;)
template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS time_get<char>; template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS time_get<char>;
template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS time_get<wchar_t>; _LIBCPP_IF_WIDE_CHARACTERS(template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS time_get<wchar_t>;)
template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS time_get_byname<char>; template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS time_get_byname<char>;
template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS time_get_byname<wchar_t>; _LIBCPP_IF_WIDE_CHARACTERS(template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS time_get_byname<wchar_t>;)
template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS time_put<char>; template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS time_put<char>;
template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS time_put<wchar_t>; _LIBCPP_IF_WIDE_CHARACTERS(template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS time_put<wchar_t>;)
template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS time_put_byname<char>; template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS time_put_byname<char>;
template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS time_put_byname<wchar_t>; _LIBCPP_IF_WIDE_CHARACTERS(template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS time_put_byname<wchar_t>;)
template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS moneypunct<char, false>; template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS moneypunct<char, false>;
template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS moneypunct<char, true>; template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS moneypunct<char, true>;
template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS moneypunct<wchar_t, false>; _LIBCPP_IF_WIDE_CHARACTERS(template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS moneypunct<wchar_t, false>;)
template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS moneypunct<wchar_t, true>; _LIBCPP_IF_WIDE_CHARACTERS(template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS moneypunct<wchar_t, true>;)
template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS moneypunct_byname<char, false>; template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS moneypunct_byname<char, false>;
template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS moneypunct_byname<char, true>; template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS moneypunct_byname<char, true>;
template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS moneypunct_byname<wchar_t, false>; _LIBCPP_IF_WIDE_CHARACTERS(template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS moneypunct_byname<wchar_t, false>;)
template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS moneypunct_byname<wchar_t, true>; _LIBCPP_IF_WIDE_CHARACTERS(template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS moneypunct_byname<wchar_t, true>;)
template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS money_get<char>; template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS money_get<char>;
template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS money_get<wchar_t>; _LIBCPP_IF_WIDE_CHARACTERS(template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS money_get<wchar_t>;)
template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS __money_get<char>; template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS __money_get<char>;
template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS __money_get<wchar_t>; _LIBCPP_IF_WIDE_CHARACTERS(template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS __money_get<wchar_t>;)
template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS money_put<char>; template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS money_put<char>;
template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS money_put<wchar_t>; _LIBCPP_IF_WIDE_CHARACTERS(template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS money_put<wchar_t>;)
template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS __money_put<char>; template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS __money_put<char>;
template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS __money_put<wchar_t>; _LIBCPP_IF_WIDE_CHARACTERS(template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS __money_put<wchar_t>;)
template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS messages<char>; template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS messages<char>;
template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS messages<wchar_t>; _LIBCPP_IF_WIDE_CHARACTERS(template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS messages<wchar_t>;)
template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS messages_byname<char>; template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS messages_byname<char>;
template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS messages_byname<wchar_t>; _LIBCPP_IF_WIDE_CHARACTERS(template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS messages_byname<wchar_t>;)
template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS codecvt_byname<char, char, mbstate_t>; template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS codecvt_byname<char, char, mbstate_t>;
template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS codecvt_byname<wchar_t, char, mbstate_t>; _LIBCPP_IF_WIDE_CHARACTERS(template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS codecvt_byname<wchar_t, char, mbstate_t>;)
template class _LIBCPP_DEPRECATED_IN_CXX20 _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS codecvt_byname<char16_t, char, mbstate_t>; template class _LIBCPP_DEPRECATED_IN_CXX20 _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS codecvt_byname<char16_t, char, mbstate_t>;
template class _LIBCPP_DEPRECATED_IN_CXX20 _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS codecvt_byname<char32_t, char, mbstate_t>; template class _LIBCPP_DEPRECATED_IN_CXX20 _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS codecvt_byname<char32_t, char, mbstate_t>;
#ifndef _LIBCPP_HAS_NO_CHAR8_T #ifndef _LIBCPP_HAS_NO_CHAR8_T
template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS codecvt_byname<char16_t, char8_t, mbstate_t>; template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS codecvt_byname<char16_t, char8_t, mbstate_t>;
template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS codecvt_byname<char32_t, char8_t, mbstate_t>; template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS codecvt_byname<char32_t, char8_t, mbstate_t>;
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD

libcxx/src/string.cpp

libcxx/test/libcxx/atomics/atomics.align/align.pass.cpp

libcxx/test/libcxx/depr/depr.c.headers/extern_c.pass.cpp

libcxx/test/libcxx/diagnostics/detail.headers/mbstate_t.h.module.verify.cpp

libcxx/test/libcxx/double_include.sh.cpp

libcxx/test/libcxx/include_as_c.sh.cpp

libcxx/test/libcxx/input.output/filesystems/class.path/path.member/path.native.obs/string_alloc.pass.cpp

libcxx/test/libcxx/input.output/filesystems/class.path/path.req/is_pathable.pass.cpp

libcxx/test/libcxx/input.output/iostream.format/input.streams/traits_mismatch.fail.cpp

libcxx/test/libcxx/input.output/iostream.format/output.streams/traits_mismatch.fail.cpp

libcxx/test/libcxx/input.output/string.streams/traits_mismatch.fail.cpp

libcxx/test/libcxx/iterators/contiguous_iterators.pass.cpp

libcxx/test/libcxx/iterators/failed.pass.cpp

libcxx/test/libcxx/iterators/iterator.requirements/iterator.concepts/integer_like.compile.pass.cpp

libcxx/test/libcxx/localization/locales/locale.convenience/conversions/conversions.string/ctor_move.pass.cpp

libcxx/test/libcxx/min_max_macros.compile.pass.cpp

libcxx/test/libcxx/no_assert_include.compile.pass.cpp

libcxx/test/libcxx/strings/c.strings/version_cwchar.pass.cpp

libcxx/test/libcxx/strings/c.strings/version_cwctype.pass.cpp

libcxx/test/libcxx/type_traits/convert_to_integral.pass.cpp

libcxx/test/libcxx/utilities/format/format.arguments/format.arg/visit_format_arg.pass.cpp

libcxx/test/libcxx/utilities/format/format.arguments/format.args/get.pass.cpp

libcxx/test/libcxx/utilities/format/format.string/format.string.std/std_format_spec_bool.pass.cpp

libcxx/test/libcxx/utilities/format/format.string/format.string.std/std_format_spec_char.pass.cpp

libcxx/test/libcxx/utilities/format/format.string/format.string.std/std_format_spec_integer.pass.cpp

libcxx/test/libcxx/utilities/format/format.string/format.string.std/std_format_spec_string.pass.cpp

libcxx/test/libcxx/utilities/format/format.string/format.string.std/std_format_spec_string_non_unicode.pass.cpp

libcxx/test/libcxx/utilities/format/format.string/format.string.std/std_format_spec_string_unicode.pass.cpp

libcxx/test/std/atomics/atomics.types.generic/integral.pass.cpp

libcxx/test/std/atomics/atomics.types.generic/integral_typedefs.pass.cpp

libcxx/test/std/atomics/types.pass.cpp

libcxx/test/std/concepts/concepts.lang/concept.default.init/default_initializable.compile.pass.cpp

libcxx/test/std/depr/depr.c.headers/stdint_h.pass.cpp

libcxx/test/std/depr/depr.c.headers/wchar_h.pass.cpp

libcxx/test/std/depr/depr.c.headers/wctype_h.pass.cpp

libcxx/test/std/experimental/iterator/ostream.joiner/ostream.joiner.cons/ostream_joiner.cons.pass.cpp

libcxx/test/std/experimental/iterator/ostream.joiner/ostream.joiner.ops/ostream_joiner.op.assign.pass.cpp

libcxx/test/std/experimental/iterator/ostream.joiner/ostream.joiner.ops/ostream_joiner.op.postincrement.pass.cpp

libcxx/test/std/experimental/iterator/ostream.joiner/ostream.joiner.ops/ostream_joiner.op.pretincrement.pass.cpp

libcxx/test/std/experimental/iterator/ostream.joiner/ostream.joiner.ops/ostream_joiner.op.star.pass.cpp

libcxx/test/std/experimental/memory/memory.resource.aliases/header_regex_synop.pass.cpp

libcxx/test/std/experimental/memory/memory.resource.aliases/header_string_synop.pass.cpp

libcxx/test/std/input.output/file.streams/c.files/cinttypes.pass.cpp

libcxx/test/std/input.output/file.streams/fstreams/filebuf.assign/member_swap.pass.cpp

libcxx/test/std/input.output/file.streams/fstreams/filebuf.assign/move_assign.pass.cpp

libcxx/test/std/input.output/file.streams/fstreams/filebuf.assign/nonmember_swap.pass.cpp

libcxx/test/std/input.output/file.streams/fstreams/filebuf.cons/default.pass.cpp

libcxx/test/std/input.output/file.streams/fstreams/filebuf.cons/move.pass.cpp

libcxx/test/std/input.output/file.streams/fstreams/filebuf.members/open_path.pass.cpp

libcxx/test/std/input.output/file.streams/fstreams/filebuf.members/open_pointer.pass.cpp

libcxx/test/std/input.output/file.streams/fstreams/filebuf.virtuals/overflow.pass.cpp

libcxx/test/std/input.output/file.streams/fstreams/filebuf.virtuals/seekoff.pass.cpp

libcxx/test/std/input.output/file.streams/fstreams/filebuf.virtuals/underflow.pass.cpp

libcxx/test/std/input.output/file.streams/fstreams/fstream.assign/member_swap.pass.cpp

libcxx/test/std/input.output/file.streams/fstreams/fstream.assign/move_assign.pass.cpp

libcxx/test/std/input.output/file.streams/fstreams/fstream.assign/nonmember_swap.pass.cpp

libcxx/test/std/input.output/file.streams/fstreams/fstream.cons/default.pass.cpp

libcxx/test/std/input.output/file.streams/fstreams/fstream.cons/move.pass.cpp

libcxx/test/std/input.output/file.streams/fstreams/fstream.cons/path.pass.cpp

libcxx/test/std/input.output/file.streams/fstreams/fstream.cons/pointer.pass.cpp

libcxx/test/std/input.output/file.streams/fstreams/fstream.cons/string.pass.cpp

libcxx/test/std/input.output/file.streams/fstreams/fstream.members/close.pass.cpp

libcxx/test/std/input.output/file.streams/fstreams/fstream.members/open_path.pass.cpp

libcxx/test/std/input.output/file.streams/fstreams/fstream.members/open_pointer.pass.cpp

libcxx/test/std/input.output/file.streams/fstreams/fstream.members/open_string.pass.cpp

libcxx/test/std/input.output/file.streams/fstreams/fstream.members/rdbuf.pass.cpp

libcxx/test/std/input.output/file.streams/fstreams/ifstream.assign/member_swap.pass.cpp

libcxx/test/std/input.output/file.streams/fstreams/ifstream.assign/move_assign.pass.cpp

libcxx/test/std/input.output/file.streams/fstreams/ifstream.assign/nonmember_swap.pass.cpp

libcxx/test/std/input.output/file.streams/fstreams/ifstream.cons/default.pass.cpp

libcxx/test/std/input.output/file.streams/fstreams/ifstream.cons/move.pass.cpp

libcxx/test/std/input.output/file.streams/fstreams/ifstream.cons/path.pass.cpp

libcxx/test/std/input.output/file.streams/fstreams/ifstream.cons/pointer.pass.cpp

libcxx/test/std/input.output/file.streams/fstreams/ifstream.cons/string.pass.cpp

libcxx/test/std/input.output/file.streams/fstreams/ifstream.members/close.pass.cpp

libcxx/test/std/input.output/file.streams/fstreams/ifstream.members/open_path.pass.cpp

libcxx/test/std/input.output/file.streams/fstreams/ifstream.members/open_pointer.pass.cpp

libcxx/test/std/input.output/file.streams/fstreams/ifstream.members/open_string.pass.cpp

libcxx/test/std/input.output/file.streams/fstreams/ifstream.members/rdbuf.pass.cpp

libcxx/test/std/input.output/file.streams/fstreams/ofstream.assign/member_swap.pass.cpp

libcxx/test/std/input.output/file.streams/fstreams/ofstream.assign/move_assign.pass.cpp

libcxx/test/std/input.output/file.streams/fstreams/ofstream.assign/nonmember_swap.pass.cpp

libcxx/test/std/input.output/file.streams/fstreams/ofstream.cons/default.pass.cpp

libcxx/test/std/input.output/file.streams/fstreams/ofstream.cons/move.pass.cpp

libcxx/test/std/input.output/file.streams/fstreams/ofstream.cons/path.pass.cpp

libcxx/test/std/input.output/file.streams/fstreams/ofstream.cons/pointer.pass.cpp

libcxx/test/std/input.output/file.streams/fstreams/ofstream.cons/string.pass.cpp

libcxx/test/std/input.output/file.streams/fstreams/ofstream.members/close.pass.cpp

libcxx/test/std/input.output/file.streams/fstreams/ofstream.members/open_path.pass.cpp

libcxx/test/std/input.output/file.streams/fstreams/ofstream.members/open_pointer.pass.cpp

libcxx/test/std/input.output/file.streams/fstreams/ofstream.members/open_string.pass.cpp

libcxx/test/std/input.output/file.streams/fstreams/ofstream.members/rdbuf.pass.cpp

libcxx/test/std/input.output/filesystems/class.path/path.member/path.append.pass.cpp

libcxx/test/std/input.output/filesystems/class.path/path.member/path.assign/source.pass.cpp

libcxx/test/std/input.output/filesystems/class.path/path.member/path.charconv.pass.cpp

libcxx/test/std/input.output/filesystems/class.path/path.member/path.concat.pass.cpp

libcxx/test/std/input.output/filesystems/class.path/path.member/path.construct/source.pass.cpp

libcxx/test/std/input.output/filesystems/class.path/path.member/path.generic.obs/generic_string_alloc.pass.cpp

libcxx/test/std/input.output/filesystems/class.path/path.member/path.generic.obs/named_overloads.pass.cpp

libcxx/test/std/input.output/filesystems/class.path/path.member/path.native.obs/named_overloads.pass.cpp

libcxx/test/std/input.output/filesystems/class.path/path.nonmember/path.io.pass.cpp

libcxx/test/std/input.output/iostream.format/ext.manip/get_money.pass.cpp

libcxx/test/std/input.output/iostream.format/ext.manip/get_time.pass.cpp

libcxx/test/std/input.output/iostream.format/ext.manip/put_money.pass.cpp

libcxx/test/std/input.output/iostream.format/ext.manip/put_time.pass.cpp

libcxx/test/std/input.output/iostream.format/input.streams/iostreamclass/iostream.assign/member_swap.pass.cpp

libcxx/test/std/input.output/iostream.format/input.streams/iostreamclass/iostream.assign/move_assign.pass.cpp

libcxx/test/std/input.output/iostream.format/input.streams/iostreamclass/iostream.cons/move.pass.cpp

libcxx/test/std/input.output/iostream.format/input.streams/iostreamclass/iostream.cons/streambuf.pass.cpp

libcxx/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/bool.pass.cpp

libcxx/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/double.pass.cpp

libcxx/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/float.pass.cpp

libcxx/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/int.pass.cpp

libcxx/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/long.pass.cpp

libcxx/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/long_double.pass.cpp

libcxx/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/long_long.pass.cpp

libcxx/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/pointer.pass.cpp

libcxx/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/short.pass.cpp

libcxx/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/unsigned_int.pass.cpp

libcxx/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/unsigned_long.pass.cpp

libcxx/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/unsigned_long_long.pass.cpp

libcxx/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/unsigned_short.pass.cpp

libcxx/test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/chart.pass.cpp

libcxx/test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/streambuf.pass.cpp

libcxx/test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/wchar_t_pointer.pass.cpp

libcxx/test/std/input.output/iostream.format/input.streams/istream.manip/ws.pass.cpp

libcxx/test/std/input.output/iostream.format/input.streams/istream.rvalue/rvalue.pass.cpp

libcxx/test/std/input.output/iostream.format/input.streams/istream.unformatted/get.pass.cpp

libcxx/test/std/input.output/iostream.format/input.streams/istream.unformatted/get_chart.pass.cpp

libcxx/test/std/input.output/iostream.format/input.streams/istream.unformatted/get_pointer_size.pass.cpp

libcxx/test/std/input.output/iostream.format/input.streams/istream.unformatted/get_pointer_size_chart.pass.cpp

libcxx/test/std/input.output/iostream.format/input.streams/istream.unformatted/get_streambuf.pass.cpp

libcxx/test/std/input.output/iostream.format/input.streams/istream.unformatted/get_streambuf_chart.pass.cpp

libcxx/test/std/input.output/iostream.format/input.streams/istream.unformatted/getline_pointer_size.pass.cpp

libcxx/test/std/input.output/iostream.format/input.streams/istream.unformatted/getline_pointer_size_chart.pass.cpp

libcxx/test/std/input.output/iostream.format/input.streams/istream.unformatted/ignore.pass.cpp

libcxx/test/std/input.output/iostream.format/input.streams/istream.unformatted/peek.pass.cpp

libcxx/test/std/input.output/iostream.format/input.streams/istream.unformatted/putback.pass.cpp

libcxx/test/std/input.output/iostream.format/input.streams/istream.unformatted/read.pass.cpp

libcxx/test/std/input.output/iostream.format/input.streams/istream.unformatted/readsome.pass.cpp

libcxx/test/std/input.output/iostream.format/input.streams/istream.unformatted/seekg.pass.cpp

libcxx/test/std/input.output/iostream.format/input.streams/istream.unformatted/seekg_off.pass.cpp

libcxx/test/std/input.output/iostream.format/input.streams/istream.unformatted/sync.pass.cpp

libcxx/test/std/input.output/iostream.format/input.streams/istream.unformatted/tellg.pass.cpp

libcxx/test/std/input.output/iostream.format/input.streams/istream.unformatted/unget.pass.cpp

libcxx/test/std/input.output/iostream.format/input.streams/istream/istream.assign/member_swap.pass.cpp

libcxx/test/std/input.output/iostream.format/input.streams/istream/istream.assign/move_assign.pass.cpp

libcxx/test/std/input.output/iostream.format/input.streams/istream/istream.cons/move.pass.cpp

libcxx/test/std/input.output/iostream.format/input.streams/istream/istream.cons/streambuf.pass.cpp

libcxx/test/std/input.output/iostream.format/input.streams/istream/istream_sentry/ctor.pass.cpp

libcxx/test/std/input.output/iostream.format/output.streams/ostream.assign/member_swap.pass.cpp

libcxx/test/std/input.output/iostream.format/output.streams/ostream.assign/move_assign.pass.cpp

libcxx/test/std/input.output/iostream.format/output.streams/ostream.cons/move.pass.cpp

libcxx/test/std/input.output/iostream.format/output.streams/ostream.cons/streambuf.pass.cpp

libcxx/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/CharT.pass.cpp

libcxx/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/CharT_pointer.pass.cpp

libcxx/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/char_to_wide.pass.cpp

libcxx/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/char_to_wide_pointer.pass.cpp

libcxx/test/std/input.output/iostream.format/output.streams/ostream.manip/endl.pass.cpp

libcxx/test/std/input.output/iostream.format/output.streams/ostream.manip/ends.pass.cpp

libcxx/test/std/input.output/iostream.format/output.streams/ostream.manip/flush.pass.cpp

libcxx/test/std/input.output/iostream.format/output.streams/ostream.rvalue/rvalue.pass.cpp

libcxx/test/std/input.output/iostream.format/output.streams/ostream.unformatted/put.pass.cpp

libcxx/test/std/input.output/iostream.format/output.streams/ostream.unformatted/write.pass.cpp

libcxx/test/std/input.output/iostream.format/quoted.manip/quoted.pass.cpp

libcxx/test/std/input.output/iostream.format/quoted.manip/quoted_char.verify.cpp

libcxx/test/std/input.output/iostream.format/std.manip/resetiosflags.pass.cpp

libcxx/test/std/input.output/iostream.format/std.manip/setbase.pass.cpp

libcxx/test/std/input.output/iostream.format/std.manip/setfill.pass.cpp

libcxx/test/std/input.output/iostream.format/std.manip/setiosflags.pass.cpp

libcxx/test/std/input.output/iostream.format/std.manip/setprecision.pass.cpp

libcxx/test/std/input.output/iostream.format/std.manip/setw.pass.cpp

libcxx/test/std/input.output/iostream.forward/iosfwd.pass.cpp

libcxx/test/std/input.output/iostream.objects/init.pass.cpp

libcxx/test/std/input.output/iostream.objects/wide.stream.objects/wcerr.sh.cpp

libcxx/test/std/input.output/iostream.objects/wide.stream.objects/wcin.sh.cpp

libcxx/test/std/input.output/iostream.objects/wide.stream.objects/wclog.sh.cpp

libcxx/test/std/input.output/iostream.objects/wide.stream.objects/wcout.sh.cpp

libcxx/test/std/input.output/iostreams.base/ios/basic.ios.members/narrow.pass.cpp

libcxx/test/std/input.output/stream.buffers/streambuf/streambuf.cons/copy.pass.cpp

libcxx/test/std/input.output/stream.buffers/streambuf/streambuf.cons/default.pass.cpp

libcxx/test/std/input.output/stream.buffers/streambuf/streambuf.protected/streambuf.assign/assign.pass.cpp

libcxx/test/std/input.output/stream.buffers/streambuf/streambuf.protected/streambuf.assign/swap.pass.cpp

libcxx/test/std/input.output/stream.buffers/streambuf/streambuf.protected/streambuf.get.area/gbump.pass.cpp

libcxx/test/std/input.output/stream.buffers/streambuf/streambuf.protected/streambuf.get.area/setg.pass.cpp

libcxx/test/std/input.output/stream.buffers/streambuf/streambuf.protected/streambuf.put.area/pbump.pass.cpp

libcxx/test/std/input.output/stream.buffers/streambuf/streambuf.protected/streambuf.put.area/setp.pass.cpp

libcxx/test/std/input.output/stream.buffers/streambuf/types.pass.cpp

libcxx/test/std/input.output/string.streams/istringstream/istringstream.assign/member_swap.pass.cpp

libcxx/test/std/input.output/string.streams/istringstream/istringstream.assign/move.pass.cpp

libcxx/test/std/input.output/string.streams/istringstream/istringstream.assign/nonmember_swap.pass.cpp

libcxx/test/std/input.output/string.streams/istringstream/istringstream.cons/default.pass.cpp

libcxx/test/std/input.output/string.streams/istringstream/istringstream.cons/move.pass.cpp

libcxx/test/std/input.output/string.streams/istringstream/istringstream.cons/string.pass.cpp

libcxx/test/std/input.output/string.streams/istringstream/istringstream.members/str.pass.cpp

libcxx/test/std/input.output/string.streams/ostringstream/ostringstream.assign/member_swap.pass.cpp

libcxx/test/std/input.output/string.streams/ostringstream/ostringstream.assign/move.pass.cpp

libcxx/test/std/input.output/string.streams/ostringstream/ostringstream.assign/nonmember_swap.pass.cpp

libcxx/test/std/input.output/string.streams/ostringstream/ostringstream.cons/default.pass.cpp

libcxx/test/std/input.output/string.streams/ostringstream/ostringstream.cons/move.pass.cpp

libcxx/test/std/input.output/string.streams/ostringstream/ostringstream.cons/string.pass.cpp

libcxx/test/std/input.output/string.streams/ostringstream/ostringstream.members/str.pass.cpp

libcxx/test/std/input.output/string.streams/stringbuf/stringbuf.assign/member_swap.pass.cpp

libcxx/test/std/input.output/string.streams/stringbuf/stringbuf.assign/move.pass.cpp

libcxx/test/std/input.output/string.streams/stringbuf/stringbuf.assign/nonmember_swap.pass.cpp

libcxx/test/std/input.output/string.streams/stringbuf/stringbuf.cons/default.pass.cpp

libcxx/test/std/input.output/string.streams/stringbuf/stringbuf.cons/move.pass.cpp

libcxx/test/std/input.output/string.streams/stringbuf/stringbuf.cons/string.pass.cpp

libcxx/test/std/input.output/string.streams/stringbuf/stringbuf.members/str.pass.cpp

libcxx/test/std/input.output/string.streams/stringbuf/stringbuf.virtuals/overflow.pass.cpp

libcxx/test/std/input.output/string.streams/stringbuf/stringbuf.virtuals/pbackfail.pass.cpp

libcxx/test/std/input.output/string.streams/stringbuf/stringbuf.virtuals/seekoff.pass.cpp

libcxx/test/std/input.output/string.streams/stringbuf/stringbuf.virtuals/seekpos.pass.cpp

libcxx/test/std/input.output/string.streams/stringbuf/stringbuf.virtuals/setbuf.pass.cpp

libcxx/test/std/input.output/string.streams/stringbuf/stringbuf.virtuals/underflow.pass.cpp

libcxx/test/std/input.output/string.streams/stringstream.cons/default.pass.cpp

libcxx/test/std/input.output/string.streams/stringstream.cons/move.pass.cpp

libcxx/test/std/input.output/string.streams/stringstream.cons/string.pass.cpp

libcxx/test/std/input.output/string.streams/stringstream.cons/stringstream.assign/member_swap.pass.cpp

libcxx/test/std/input.output/string.streams/stringstream.cons/stringstream.assign/move.pass.cpp

libcxx/test/std/input.output/string.streams/stringstream.cons/stringstream.assign/nonmember_swap.pass.cpp

libcxx/test/std/input.output/string.streams/stringstream.members/str.pass.cpp

libcxx/test/std/iterators/stream.iterators/istream.iterator/types.pass.cpp

libcxx/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator.cons/default.pass.cpp

libcxx/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator.cons/istream.pass.cpp

libcxx/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator.cons/proxy.pass.cpp

libcxx/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator.cons/streambuf.pass.cpp

libcxx/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator_equal/equal.pass.cpp

libcxx/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator_op!=/not_equal.pass.cpp

libcxx/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator_op++/dereference.pass.cpp

libcxx/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator_op==/equal.pass.cpp

libcxx/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator_op_astrk/post_increment.pass.cpp

libcxx/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator_op_astrk/pre_increment.pass.cpp

libcxx/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator_proxy/proxy.pass.cpp

libcxx/test/std/iterators/stream.iterators/istreambuf.iterator/types.pass.cpp

libcxx/test/std/iterators/stream.iterators/ostream.iterator/ostream.iterator.cons.des/ostream_delim.pass.cpp

libcxx/test/std/iterators/stream.iterators/ostream.iterator/ostream.iterator.ops/assign_t.pass.cpp

libcxx/test/std/iterators/stream.iterators/ostream.iterator/types.pass.cpp

libcxx/test/std/iterators/stream.iterators/ostreambuf.iterator/ostreambuf.iter.cons/ostream.pass.cpp

libcxx/test/std/iterators/stream.iterators/ostreambuf.iterator/ostreambuf.iter.cons/streambuf.pass.cpp

libcxx/test/std/iterators/stream.iterators/ostreambuf.iterator/ostreambuf.iter.ops/assign_c.pass.cpp

libcxx/test/std/iterators/stream.iterators/ostreambuf.iterator/ostreambuf.iter.ops/deref.pass.cpp

libcxx/test/std/iterators/stream.iterators/ostreambuf.iterator/ostreambuf.iter.ops/failed.pass.cpp

libcxx/test/std/iterators/stream.iterators/ostreambuf.iterator/ostreambuf.iter.ops/increment.pass.cpp

libcxx/test/std/iterators/stream.iterators/ostreambuf.iterator/types.pass.cpp

libcxx/test/std/language.support/cstdint/cstdint.syn/cstdint.pass.cpp

libcxx/test/std/language.support/support.limits/limits/numeric.limits.members/lowest.pass.cpp

libcxx/test/std/language.support/support.limits/limits/numeric.limits.members/max.pass.cpp

libcxx/test/std/language.support/support.limits/limits/numeric.limits.members/min.pass.cpp

libcxx/test/std/localization/locale.categories/category.collate/locale.collate.byname/compare.pass.cpp

libcxx/test/std/localization/locale.categories/category.collate/locale.collate.byname/hash.pass.cpp

libcxx/test/std/localization/locale.categories/category.collate/locale.collate.byname/transform.pass.cpp

libcxx/test/std/localization/locale.categories/category.collate/locale.collate.byname/types.pass.cpp

libcxx/test/std/localization/locale.categories/category.collate/locale.collate/ctor.pass.cpp

libcxx/test/std/localization/locale.categories/category.collate/locale.collate/locale.collate.members/compare.pass.cpp

libcxx/test/std/localization/locale.categories/category.collate/locale.collate/locale.collate.members/hash.pass.cpp

libcxx/test/std/localization/locale.categories/category.collate/locale.collate/locale.collate.members/transform.pass.cpp

libcxx/test/std/localization/locale.categories/category.collate/locale.collate/types.pass.cpp

libcxx/test/std/localization/locale.categories/category.ctype/locale.codecvt.byname/ctor_wchar_t.pass.cpp

libcxx/test/std/localization/locale.categories/category.ctype/locale.codecvt/ctor_wchar_t.pass.cpp

libcxx/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/wchar_t_always_noconv.pass.cpp

libcxx/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/wchar_t_encoding.pass.cpp

libcxx/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/wchar_t_in.pass.cpp

libcxx/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/wchar_t_length.pass.cpp

libcxx/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/wchar_t_max_length.pass.cpp

libcxx/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/wchar_t_out.pass.cpp

libcxx/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/wchar_t_unshift.pass.cpp

libcxx/test/std/localization/locale.categories/category.ctype/locale.codecvt/types_wchar_t.pass.cpp

libcxx/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/is_1.pass.cpp

libcxx/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/is_many.pass.cpp

libcxx/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/mask.pass.cpp

libcxx/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/narrow_1.pass.cpp

libcxx/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/narrow_many.pass.cpp

libcxx/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/scan_is.pass.cpp

libcxx/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/scan_not.pass.cpp

libcxx/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/tolower_1.pass.cpp

libcxx/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/tolower_many.pass.cpp

libcxx/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/toupper_1.pass.cpp

libcxx/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/toupper_many.pass.cpp

libcxx/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/types.pass.cpp

libcxx/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/widen_1.pass.cpp

libcxx/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/widen_many.pass.cpp

libcxx/test/std/localization/locale.categories/category.ctype/locale.ctype/ctor.pass.cpp

libcxx/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/is_1.pass.cpp

libcxx/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/is_many.pass.cpp

libcxx/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/narrow_1.pass.cpp

libcxx/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/narrow_many.pass.cpp

libcxx/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/scan_is.pass.cpp

libcxx/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/scan_not.pass.cpp

libcxx/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/tolower_1.pass.cpp

libcxx/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/tolower_many.pass.cpp

libcxx/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/toupper_1.pass.cpp

libcxx/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/toupper_many.pass.cpp

libcxx/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/widen_1.pass.cpp

libcxx/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/widen_many.pass.cpp

libcxx/test/std/localization/locale.categories/category.ctype/locale.ctype/types.pass.cpp

libcxx/test/std/localization/locale.categories/category.messages/locale.messages/types.pass.cpp

libcxx/test/std/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.members/get_long_double_en_US.pass.cpp

libcxx/test/std/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.members/get_long_double_fr_FR.pass.cpp

libcxx/test/std/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.members/get_long_double_ru_RU.pass.cpp

libcxx/test/std/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.members/get_long_double_zh_CN.pass.cpp

libcxx/test/std/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.members/get_string_en_US.pass.cpp

libcxx/test/std/localization/locale.categories/category.monetary/locale.money.get/types.pass.cpp

libcxx/test/std/localization/locale.categories/category.monetary/locale.money.put/locale.money.put.members/put_long_double_en_US.pass.cpp

libcxx/test/std/localization/locale.categories/category.monetary/locale.money.put/locale.money.put.members/put_long_double_fr_FR.pass.cpp

libcxx/test/std/localization/locale.categories/category.monetary/locale.money.put/locale.money.put.members/put_long_double_ru_RU.pass.cpp

libcxx/test/std/localization/locale.categories/category.monetary/locale.money.put/locale.money.put.members/put_long_double_zh_CN.pass.cpp

libcxx/test/std/localization/locale.categories/category.monetary/locale.money.put/locale.money.put.members/put_string_en_US.pass.cpp

libcxx/test/std/localization/locale.categories/category.monetary/locale.money.put/types.pass.cpp

libcxx/test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/curr_symbol.pass.cpp

libcxx/test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/decimal_point.pass.cpp

libcxx/test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/frac_digits.pass.cpp

libcxx/test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/grouping.pass.cpp

libcxx/test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/neg_format.pass.cpp

libcxx/test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/negative_sign.pass.cpp

libcxx/test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/pos_format.pass.cpp

libcxx/test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/positive_sign.pass.cpp

libcxx/test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/thousands_sep.pass.cpp

libcxx/test/std/localization/locale.categories/category.monetary/locale.moneypunct/locale.moneypunct.members/curr_symbol.pass.cpp

libcxx/test/std/localization/locale.categories/category.monetary/locale.moneypunct/locale.moneypunct.members/decimal_point.pass.cpp

libcxx/test/std/localization/locale.categories/category.monetary/locale.moneypunct/locale.moneypunct.members/frac_digits.pass.cpp

libcxx/test/std/localization/locale.categories/category.monetary/locale.moneypunct/locale.moneypunct.members/grouping.pass.cpp

libcxx/test/std/localization/locale.categories/category.monetary/locale.moneypunct/locale.moneypunct.members/neg_format.pass.cpp

libcxx/test/std/localization/locale.categories/category.monetary/locale.moneypunct/locale.moneypunct.members/negative_sign.pass.cpp

libcxx/test/std/localization/locale.categories/category.monetary/locale.moneypunct/locale.moneypunct.members/pos_format.pass.cpp

libcxx/test/std/localization/locale.categories/category.monetary/locale.moneypunct/locale.moneypunct.members/positive_sign.pass.cpp

libcxx/test/std/localization/locale.categories/category.monetary/locale.moneypunct/locale.moneypunct.members/thousands_sep.pass.cpp

libcxx/test/std/localization/locale.categories/category.monetary/locale.moneypunct/types.pass.cpp

libcxx/test/std/localization/locale.categories/category.numeric/locale.nm.put/types.pass.cpp

libcxx/test/std/localization/locale.categories/category.time/locale.time.get.byname/date_order_wide.pass.cpp

libcxx/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_date_wide.pass.cpp

libcxx/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_monthname_wide.pass.cpp

libcxx/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_one_wide.pass.cpp

libcxx/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_time_wide.pass.cpp

libcxx/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_weekday_wide.pass.cpp

libcxx/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_year_wide.pass.cpp

libcxx/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_date_wide.pass.cpp

libcxx/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_monthname_wide.pass.cpp

libcxx/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_time_wide.pass.cpp

libcxx/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_weekday_wide.pass.cpp

libcxx/test/std/localization/locale.categories/facet.numpunct/locale.numpunct.byname/decimal_point.pass.cpp

libcxx/test/std/localization/locale.categories/facet.numpunct/locale.numpunct.byname/grouping.pass.cpp

libcxx/test/std/localization/locale.categories/facet.numpunct/locale.numpunct.byname/thousands_sep.pass.cpp

libcxx/test/std/localization/locale.categories/facet.numpunct/locale.numpunct/ctor.pass.cpp

libcxx/test/std/localization/locale.categories/facet.numpunct/locale.numpunct/facet.numpunct.members/decimal_point.pass.cpp

libcxx/test/std/localization/locale.categories/facet.numpunct/locale.numpunct/facet.numpunct.members/falsename.pass.cpp

libcxx/test/std/localization/locale.categories/facet.numpunct/locale.numpunct/facet.numpunct.members/grouping.pass.cpp

libcxx/test/std/localization/locale.categories/facet.numpunct/locale.numpunct/facet.numpunct.members/thousands_sep.pass.cpp

libcxx/test/std/localization/locale.categories/facet.numpunct/locale.numpunct/facet.numpunct.members/truename.pass.cpp

libcxx/test/std/localization/locale.categories/facet.numpunct/locale.numpunct/types.pass.cpp

libcxx/test/std/localization/locale.stdcvt/codecvt_utf16.pass.cpp

libcxx/test/std/localization/locale.stdcvt/codecvt_utf16_always_noconv.pass.cpp

libcxx/test/std/localization/locale.stdcvt/codecvt_utf16_encoding.pass.cpp

libcxx/test/std/localization/locale.stdcvt/codecvt_utf16_max_length.pass.cpp

libcxx/test/std/localization/locale.stdcvt/codecvt_utf16_out.pass.cpp

libcxx/test/std/localization/locale.stdcvt/codecvt_utf16_unshift.pass.cpp

libcxx/test/std/localization/locale.stdcvt/codecvt_utf8.pass.cpp

libcxx/test/std/localization/locale.stdcvt/codecvt_utf8_always_noconv.pass.cpp

libcxx/test/std/localization/locale.stdcvt/codecvt_utf8_encoding.pass.cpp

libcxx/test/std/localization/locale.stdcvt/codecvt_utf8_length.pass.cpp

libcxx/test/std/localization/locale.stdcvt/codecvt_utf8_max_length.pass.cpp

libcxx/test/std/localization/locale.stdcvt/codecvt_utf8_out.pass.cpp

libcxx/test/std/localization/locale.stdcvt/codecvt_utf8_unshift.pass.cpp

libcxx/test/std/localization/locale.stdcvt/codecvt_utf8_utf16_always_noconv.pass.cpp

libcxx/test/std/localization/locale.stdcvt/codecvt_utf8_utf16_encoding.pass.cpp

libcxx/test/std/localization/locale.stdcvt/codecvt_utf8_utf16_in.pass.cpp

libcxx/test/std/localization/locale.stdcvt/codecvt_utf8_utf16_length.pass.cpp

libcxx/test/std/localization/locale.stdcvt/codecvt_utf8_utf16_max_length.pass.cpp

libcxx/test/std/localization/locale.stdcvt/codecvt_utf8_utf16_out.pass.cpp

libcxx/test/std/localization/locale.stdcvt/codecvt_utf8_utf16_unshift.pass.cpp

libcxx/test/std/localization/locales/locale.convenience/conversions/conversions.buffer/ctor.pass.cpp

libcxx/test/std/localization/locales/locale.convenience/conversions/conversions.buffer/overflow.pass.cpp

libcxx/test/std/localization/locales/locale.convenience/conversions/conversions.buffer/pbackfail.pass.cpp

libcxx/test/std/localization/locales/locale.convenience/conversions/conversions.buffer/rdbuf.pass.cpp

libcxx/test/std/localization/locales/locale.convenience/conversions/conversions.buffer/seekoff.pass.cpp

libcxx/test/std/localization/locales/locale.convenience/conversions/conversions.buffer/state.pass.cpp

libcxx/test/std/localization/locales/locale.convenience/conversions/conversions.buffer/test.pass.cpp

libcxx/test/std/localization/locales/locale.convenience/conversions/conversions.buffer/underflow.pass.cpp

libcxx/test/std/localization/locales/locale.convenience/conversions/conversions.string/converted.pass.cpp

libcxx/test/std/localization/locales/locale.convenience/conversions/conversions.string/ctor_codecvt.pass.cpp

libcxx/test/std/localization/locales/locale.convenience/conversions/conversions.string/ctor_codecvt_state.pass.cpp

libcxx/test/std/localization/locales/locale.convenience/conversions/conversions.string/ctor_copy.pass.cpp

libcxx/test/std/localization/locales/locale.convenience/conversions/conversions.string/ctor_err_string.pass.cpp

libcxx/test/std/localization/locales/locale.convenience/conversions/conversions.string/from_bytes.pass.cpp

libcxx/test/std/localization/locales/locale.convenience/conversions/conversions.string/state.pass.cpp

libcxx/test/std/localization/locales/locale.convenience/conversions/conversions.string/to_bytes.pass.cpp

libcxx/test/std/localization/locales/locale.convenience/conversions/conversions.string/types.pass.cpp

libcxx/test/std/localization/locales/locale/locale.cons/assign.pass.cpp

libcxx/test/std/localization/locales/locale/locale.cons/char_pointer.pass.cpp

libcxx/test/std/localization/locales/locale/locale.cons/copy.pass.cpp

libcxx/test/std/localization/locales/locale/locale.cons/default.pass.cpp

libcxx/test/std/localization/locales/locale/locale.cons/locale_char_pointer_cat.pass.cpp

libcxx/test/std/localization/locales/locale/locale.cons/locale_facetptr.pass.cpp

libcxx/test/std/localization/locales/locale/locale.cons/locale_locale_cat.pass.cpp

libcxx/test/std/localization/locales/locale/locale.cons/locale_string_cat.pass.cpp

libcxx/test/std/localization/locales/locale/locale.cons/string.pass.cpp

libcxx/test/std/localization/locales/locale/locale.members/combine.pass.cpp

libcxx/test/std/localization/locales/locale/locale.operators/compare.pass.cpp

libcxx/test/std/localization/locales/locale/locale.statics/classic.pass.cpp

libcxx/test/std/localization/locales/locale/locale.statics/global.pass.cpp

libcxx/test/std/namespace/addressable_functions.sh.cpp

libcxx/test/std/ranges/range.utility/range.subrange/ctad.compile.pass.cpp

libcxx/test/std/re/re.alg/re.alg.match/awk.locale.pass.cpp

libcxx/test/std/re/re.alg/re.alg.match/awk.pass.cpp

libcxx/test/std/re/re.alg/re.alg.match/basic.locale.pass.cpp

libcxx/test/std/re/re.alg/re.alg.match/basic.pass.cpp

libcxx/test/std/re/re.alg/re.alg.match/ecma.locale.pass.cpp

libcxx/test/std/re/re.alg/re.alg.match/ecma.pass.cpp

libcxx/test/std/re/re.alg/re.alg.match/extended.locale.pass.cpp

libcxx/test/std/re/re.alg/re.alg.match/extended.pass.cpp

libcxx/test/std/re/re.alg/re.alg.search/awk.locale.pass.cpp

libcxx/test/std/re/re.alg/re.alg.search/awk.pass.cpp

libcxx/test/std/re/re.alg/re.alg.search/basic.locale.pass.cpp

libcxx/test/std/re/re.alg/re.alg.search/basic.pass.cpp

libcxx/test/std/re/re.alg/re.alg.search/ecma.locale.pass.cpp

libcxx/test/std/re/re.alg/re.alg.search/ecma.pass.cpp

libcxx/test/std/re/re.alg/re.alg.search/extended.locale.pass.cpp

libcxx/test/std/re/re.alg/re.alg.search/extended.pass.cpp

libcxx/test/std/re/re.iter/re.regiter/re.regiter.cnstr/default.pass.cpp

libcxx/test/std/re/re.iter/re.regiter/types.pass.cpp

libcxx/test/std/re/re.regex/re.regex.construct/deduct.pass.cpp

libcxx/test/std/re/re.regex/re.regex.construct/default.pass.cpp

libcxx/test/std/re/re.results/re.results.all/get_allocator.pass.cpp

libcxx/test/std/re/re.results/re.results.const/allocator.pass.cpp

libcxx/test/std/re/re.results/re.results.const/copy.pass.cpp

libcxx/test/std/re/re.results/re.results.const/copy_assign.pass.cpp

libcxx/test/std/re/re.results/re.results.const/default.pass.cpp

libcxx/test/std/re/re.results/re.results.const/move.pass.cpp

libcxx/test/std/re/re.results/re.results.const/move_assign.pass.cpp

libcxx/test/std/re/re.results/re.results.form/form1.pass.cpp

libcxx/test/std/re/re.results/re.results.form/form2.pass.cpp

libcxx/test/std/re/re.results/re.results.form/form3.pass.cpp

libcxx/test/std/re/re.results/re.results.form/form4.pass.cpp

libcxx/test/std/re/re.submatch/re.submatch.members/compare_string_type.pass.cpp

libcxx/test/std/re/re.submatch/re.submatch.members/compare_sub_match.pass.cpp

libcxx/test/std/re/re.submatch/re.submatch.members/compare_value_type_ptr.pass.cpp

libcxx/test/std/re/re.submatch/re.submatch.members/default.pass.cpp

libcxx/test/std/re/re.submatch/re.submatch.members/length.pass.cpp

libcxx/test/std/re/re.submatch/re.submatch.members/operator_string.pass.cpp

libcxx/test/std/re/re.submatch/re.submatch.members/str.pass.cpp

libcxx/test/std/re/re.submatch/re.submatch.op/compare.pass.cpp

libcxx/test/std/re/re.submatch/re.submatch.op/stream.pass.cpp

libcxx/test/std/re/re.submatch/types.pass.cpp

libcxx/test/std/re/re.syn/wcmatch.pass.cpp

libcxx/test/std/re/re.syn/wcregex_iterator.pass.cpp

libcxx/test/std/re/re.syn/wcregex_token_iterator.pass.cpp

libcxx/test/std/re/re.syn/wcsub_match.pass.cpp

libcxx/test/std/re/re.syn/wregex.pass.cpp

libcxx/test/std/re/re.syn/wsmatch.pass.cpp

libcxx/test/std/re/re.syn/wsregex_iterator.pass.cpp

libcxx/test/std/re/re.syn/wsregex_token_iterator.pass.cpp

libcxx/test/std/re/re.syn/wssub_match.pass.cpp

libcxx/test/std/re/re.traits/default.pass.cpp

libcxx/test/std/re/re.traits/getloc.pass.cpp

libcxx/test/std/re/re.traits/isctype.pass.cpp

libcxx/test/std/re/re.traits/length.pass.cpp

libcxx/test/std/re/re.traits/lookup_classname.pass.cpp

libcxx/test/std/re/re.traits/lookup_collatename.pass.cpp

libcxx/test/std/re/re.traits/transform.pass.cpp

libcxx/test/std/re/re.traits/transform_primary.pass.cpp

libcxx/test/std/re/re.traits/translate.pass.cpp

libcxx/test/std/re/re.traits/translate_nocase.pass.cpp

libcxx/test/std/re/re.traits/types.pass.cpp

libcxx/test/std/re/re.traits/value.pass.cpp

libcxx/test/std/strings/basic.string.hash/enabled_hashes.pass.cpp

libcxx/test/std/strings/basic.string.hash/strings.pass.cpp

libcxx/test/std/strings/basic.string.literals/literal.pass.cpp

libcxx/test/std/strings/basic.string/string.cons/dtor_noexcept.pass.cpp

libcxx/test/std/strings/basic.string/string.cons/implicit_deduction_guides.pass.cpp

libcxx/test/std/strings/basic.string/string.cons/initializer_list.pass.cpp

libcxx/test/std/strings/basic.string/string.cons/string_view_deduction.pass.cpp

libcxx/test/std/strings/basic.string/string.cons/string_view_size_size_deduction.pass.cpp

libcxx/test/std/strings/basic.string/string.iterators/iterators.pass.cpp

libcxx/test/std/strings/basic.string/string.nonmembers/string.io/get_line.pass.cpp

libcxx/test/std/strings/basic.string/string.nonmembers/string.io/get_line_delim.pass.cpp

libcxx/test/std/strings/basic.string/string.nonmembers/string.io/get_line_delim_rv.pass.cpp

libcxx/test/std/strings/basic.string/string.nonmembers/string.io/get_line_rv.pass.cpp

libcxx/test/std/strings/basic.string/string.nonmembers/string.io/stream_extract.pass.cpp

libcxx/test/std/strings/basic.string/string.nonmembers/string.io/stream_insert.pass.cpp

libcxx/test/std/strings/c.strings/cwchar.pass.cpp

libcxx/test/std/strings/c.strings/cwctype.pass.cpp

libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/assign2.pass.cpp

libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/assign3.pass.cpp

libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/compare.pass.cpp

libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/copy.pass.cpp

libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/eof.pass.cpp

libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/eq.pass.cpp

libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/eq_int_type.pass.cpp

libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/find.pass.cpp

libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/length.pass.cpp

libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/lt.pass.cpp

libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/move.pass.cpp

libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/not_eof.pass.cpp

libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/to_char_type.pass.cpp

libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/to_int_type.pass.cpp

libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/types.pass.cpp

libcxx/test/std/strings/string.classes/typedefs.pass.cpp

libcxx/test/std/strings/string.conversions/stod.pass.cpp

libcxx/test/std/strings/string.conversions/stof.pass.cpp

libcxx/test/std/strings/string.conversions/stoi.pass.cpp

libcxx/test/std/strings/string.conversions/stol.pass.cpp

libcxx/test/std/strings/string.conversions/stold.pass.cpp

libcxx/test/std/strings/string.conversions/stoll.pass.cpp

libcxx/test/std/strings/string.conversions/stoul.pass.cpp

libcxx/test/std/strings/string.conversions/stoull.pass.cpp

libcxx/test/std/strings/string.conversions/to_wstring.pass.cpp

libcxx/test/std/strings/string.view/string.view.hash/enabled_hashes.pass.cpp

libcxx/test/std/strings/string.view/string.view.hash/string_view.pass.cpp

libcxx/test/std/strings/string.view/string.view.capacity/capacity.pass.cpp

libcxx/test/std/strings/string.view/string.view.cons/assign.pass.cpp

libcxx/test/std/strings/string.view/string.view.cons/default.pass.cpp

libcxx/test/std/strings/string.view/string.view.cons/from_string.pass.cpp

libcxx/test/std/strings/string.view/string.view.cons/implicit_deduction_guides.pass.cpp

libcxx/test/std/strings/string.view/string.view.io/stream_insert.pass.cpp

libcxx/test/std/strings/string.view/string.view.iterators/begin.pass.cpp

libcxx/test/std/strings/string.view/string.view.iterators/end.pass.cpp

libcxx/test/std/strings/string.view/string.view.iterators/rbegin.pass.cpp

libcxx/test/std/strings/string.view/string.view.iterators/rend.pass.cpp

libcxx/test/std/strings/string.view/string.view.modifiers/remove_prefix.pass.cpp

libcxx/test/std/strings/string.view/string.view.modifiers/remove_suffix.pass.cpp

libcxx/test/std/strings/string.view/string.view.modifiers/swap.pass.cpp

libcxx/test/std/strings/string.view/string.view.nonmem/quoted.pass.cpp

libcxx/test/std/strings/string.view/string_view.literals/literal.pass.cpp

libcxx/test/std/utilities/format/format.arguments/format.arg.store/class.pass.cpp

libcxx/test/std/utilities/format/format.arguments/format.arg.store/make_format_args.sh.cpp

libcxx/test/std/utilities/format/format.arguments/format.arg.store/make_wformat_args.pass.cpp

libcxx/test/std/utilities/format/format.arguments/format.args/ctor.pass.cpp

libcxx/test/std/utilities/format/format.arguments/format.args/types.compile.pass.cpp

libcxx/test/std/utilities/format/format.formatter/format.context/format.context/advance_to.pass.cpp

libcxx/test/std/utilities/format/format.formatter/format.context/format.context/arg.pass.cpp

libcxx/test/std/utilities/format/format.formatter/format.context/format.context/ctor.pass.cpp

libcxx/test/std/utilities/format/format.formatter/format.context/format.context/locale.pass.cpp

libcxx/test/std/utilities/format/format.formatter/format.context/format.context/out.pass.cpp

libcxx/test/std/utilities/format/format.formatter/format.context/format.formatter.spec/formatter.bool.pass.cpp

libcxx/test/std/utilities/format/format.formatter/format.context/format.formatter.spec/formatter.c_string.pass.cpp

libcxx/test/std/utilities/format/format.formatter/format.context/format.formatter.spec/formatter.char.pass.cpp

libcxx/test/std/utilities/format/format.formatter/format.context/format.formatter.spec/formatter.const_char_array.pass.cpp

libcxx/test/std/utilities/format/format.formatter/format.context/format.formatter.spec/formatter.floating_point.pass.cpp

libcxx/test/std/utilities/format/format.formatter/format.context/format.formatter.spec/formatter.signed_integral.pass.cpp

libcxx/test/std/utilities/format/format.formatter/format.context/format.formatter.spec/formatter.string.pass.cpp

libcxx/test/std/utilities/format/format.formatter/format.context/format.formatter.spec/formatter.unsigned_integral.pass.cpp

libcxx/test/std/utilities/format/format.formatter/format.context/types.compile.pass.cpp

libcxx/test/std/utilities/format/format.formatter/format.parse.ctx/types.compile.pass.cpp

libcxx/test/std/utilities/format/format.functions/format.locale.pass.cpp

libcxx/test/std/utilities/format/format.functions/format.pass.cpp

libcxx/test/std/utilities/format/format.functions/format_tests.h

libcxx/test/std/utilities/format/format.functions/format_to.locale.pass.cpp

libcxx/test/std/utilities/format/format.functions/format_to.pass.cpp

libcxx/test/std/utilities/format/format.functions/format_to_n.locale.pass.cpp

libcxx/test/std/utilities/format/format.functions/format_to_n.pass.cpp

libcxx/test/std/utilities/format/format.functions/formatted_size.locale.pass.cpp

libcxx/test/std/utilities/format/format.functions/formatted_size.pass.cpp

libcxx/test/std/utilities/format/format.functions/locale-specific_form.pass.cpp

libcxx/test/std/utilities/format/format.functions/vformat.locale.pass.cpp

libcxx/test/std/utilities/format/format.functions/vformat.pass.cpp

libcxx/test/std/utilities/format/format.functions/vformat_to.locale.pass.cpp

libcxx/test/std/utilities/format/format.functions/vformat_to.pass.cpp

libcxx/test/std/utilities/function.objects/unord.hash/integral.pass.cpp

libcxx/test/std/utilities/template.bitset/bitset.members/to_string.pass.cpp

libcxx/test/std/utilities/template.bitset/includes.pass.cpp

libcxx/test/std/utilities/utility/utility.intcmp/intcmp.fail.cpp

libcxx/test/support/make_string.h

libcxx/test/support/poisoned_hash_helper.h

libcxx/test/support/test.support/make_string_header.pass.cpp

libcxx/test/support/test_macros.h

libcxx/utils/ci/buildkite-pipeline.yml

libcxx/utils/ci/run-buildbot

libcxx/utils/generate_header_tests.py

libcxx/utils/libcxx/test/features.py