maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity
llvm-project/libcxx/include/format

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

798 lines
33 KiB
Plaintext
Raw Normal View History

[libc++] Implement format_error. This is the first step at implementing <format>. It adds the <format> header and implements the `format_error`. class. Implemnts parts of: -P0645 Text Formatting Reviewed By: ldionne, #libc, miscco, curdeius Differential Revision: https://reviews.llvm.org/D92214
2020-11-27 02:12:18 +08:00
// -*- C++ -*-
[runtimes][NFC] Remove filenames at the top of the license notice We've stopped doing it in libc++ for a while now because these names would end up rotting as we move things around and copy/paste stuff. This cleans up all the existing files so as to stop the spreading as people copy-paste headers around.
2021-11-18 05:25:01 +08:00
//===----------------------------------------------------------------------===//
[libc++] Implement format_error. This is the first step at implementing <format>. It adds the <format> header and implements the `format_error`. class. Implemnts parts of: -P0645 Text Formatting Reviewed By: ldionne, #libc, miscco, curdeius Differential Revision: https://reviews.llvm.org/D92214
2020-11-27 02:12:18 +08:00
//
// 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_FORMAT
#define _LIBCPP_FORMAT
/*
namespace std {
[libc++][format] Add __format_arg_store. This implements the struct `__format_arg_store` and its dependencies: * the class basic_format_arg, * the class basic_format_args, * the class basic_format_context, * the function make_format_args, * the function wmake_format_args, * the function visit_format_arg, * several Standard required typedefs. The following parts will be implemented in a later patch: * the child class `basic_format_arg::handle`, * the function `basic_format_arg::basic_format_arg(const T* p)`. The following extension has been implemented: * the class basic_format_arg supports `__[u]int128_t` on platform where libc++ supports 128 bit integrals. Implements parts of: * P0645 Text Formatting Completes: * LWG3371 visit_format_arg and make_format_args are not hidden friends * LWG3542 basic_format_arg mishandles basic_string_view with custom traits Note https://mordante.github.io/blog/2021/06/05/format.html gives a bit more information about the goals and non-goals of this initial patch series. Reviewed By: #libc, ldionne, vitaut Differential Revision: https://reviews.llvm.org/D103357
2020-12-05 18:45:21 +08:00
// [format.context], class template basic_format_context
[libc++][format] Finish P0645 Text Formatting. This adjust the version macro and sets it as completed. All parts of the paper have been implemented, except for the parts replaced by later papers and LWG-issues. Adjusted the synopsis to match the synopsis in the Standard. Not yet implemented parts of P2216 and P2418 still use the P0645 wording. Completes: - P0645 Text Formatting Depends on D115991 Reviewed By: ldionne, #libc Differential Revision: https://reviews.llvm.org/D115999
2021-12-18 22:03:26 +08:00
template<class Out, class charT> class basic_format_context;
[libc++][format] Add __format_arg_store. This implements the struct `__format_arg_store` and its dependencies: * the class basic_format_arg, * the class basic_format_args, * the class basic_format_context, * the function make_format_args, * the function wmake_format_args, * the function visit_format_arg, * several Standard required typedefs. The following parts will be implemented in a later patch: * the child class `basic_format_arg::handle`, * the function `basic_format_arg::basic_format_arg(const T* p)`. The following extension has been implemented: * the class basic_format_arg supports `__[u]int128_t` on platform where libc++ supports 128 bit integrals. Implements parts of: * P0645 Text Formatting Completes: * LWG3371 visit_format_arg and make_format_args are not hidden friends * LWG3542 basic_format_arg mishandles basic_string_view with custom traits Note https://mordante.github.io/blog/2021/06/05/format.html gives a bit more information about the goals and non-goals of this initial patch series. Reviewed By: #libc, ldionne, vitaut Differential Revision: https://reviews.llvm.org/D103357
2020-12-05 18:45:21 +08:00
using format_context = basic_format_context<unspecified, char>;
using wformat_context = basic_format_context<unspecified, wchar_t>;
// [format.args], class template basic_format_args
[libc++][format] Finish P0645 Text Formatting. This adjust the version macro and sets it as completed. All parts of the paper have been implemented, except for the parts replaced by later papers and LWG-issues. Adjusted the synopsis to match the synopsis in the Standard. Not yet implemented parts of P2216 and P2418 still use the P0645 wording. Completes: - P0645 Text Formatting Depends on D115991 Reviewed By: ldionne, #libc Differential Revision: https://reviews.llvm.org/D115999
2021-12-18 22:03:26 +08:00
template<class Context> class basic_format_args;
[libc++][format] Add __format_arg_store. This implements the struct `__format_arg_store` and its dependencies: * the class basic_format_arg, * the class basic_format_args, * the class basic_format_context, * the function make_format_args, * the function wmake_format_args, * the function visit_format_arg, * several Standard required typedefs. The following parts will be implemented in a later patch: * the child class `basic_format_arg::handle`, * the function `basic_format_arg::basic_format_arg(const T* p)`. The following extension has been implemented: * the class basic_format_arg supports `__[u]int128_t` on platform where libc++ supports 128 bit integrals. Implements parts of: * P0645 Text Formatting Completes: * LWG3371 visit_format_arg and make_format_args are not hidden friends * LWG3542 basic_format_arg mishandles basic_string_view with custom traits Note https://mordante.github.io/blog/2021/06/05/format.html gives a bit more information about the goals and non-goals of this initial patch series. Reviewed By: #libc, ldionne, vitaut Differential Revision: https://reviews.llvm.org/D103357
2020-12-05 18:45:21 +08:00
using format_args = basic_format_args<format_context>;
using wformat_args = basic_format_args<wformat_context>;
[libc++][format] Implement format-string. Implements the compile-time checking of the formatting arguments. Completes: - P2216 std::format improvements Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D121530
2021-10-02 18:38:46 +08:00
// [format.fmt.string], class template basic-format-string
template<class charT, class... Args>
struct basic-format-string; // exposition only
template<class... Args>
using format-string = // exposition only
basic-format-string<char, type_identity_t<Args>...>;
template<class... Args>
using wformat-string = // exposition only
basic-format-string<wchar_t, type_identity_t<Args>...>;
[libc++][format] Implement formatters. This implements the initial version of the `std::formatter` class and its specializations. It also implements the following formatting functions: - `format` - `vformat` - `format_to` - `vformat_to` - `format_to_n` - `formatted_size` All functions have a `char` and `wchar_t` version. Parsing the format-spec and using the parsed format-spec hasn't been implemented. The code isn't optimized, neither for speed, nor for size. The goal is to have the rudimentary basics working, which can be used as a basis to improve upon. The formatters used in this commit are simple stubs that will be replaced by real formatters in later commits. The formatters that are slated to be replaced in this patch series don't have an availability macro to avoid merge conflicts. Note the formatter for `bool` uses `0` and `1` instead of "false" and "true". This will be fixed when the stub is replaced with a real formatter. Implements parts of: - P0645 Text Formatting Completes: - LWG3539 format_to must not copy models of output_iterator<const charT&> Reviewed By: ldionne, #libc, vitaut Differential Revision: https://reviews.llvm.org/D96664
2020-12-19 20:52:07 +08:00
// [format.functions], formatting functions
template<class... Args>
[libc++][format] Use forwarding references. This implements a not accepted LWG issue. Not doing so would require integral types to use the handle class instead of being directly stored in the basic_format_arg. The previous code used `std::forward` in places where it wasn't required by the Standard. These are now removed. Implements: - P2418R2 Add support for std::generator-like types to std::format - LWG 3631 basic_format_arg(T&&) should use remove_cvref_t<T> throughout Reviewed By: ldionne, #libc Differential Revision: https://reviews.llvm.org/D127570
2021-10-06 01:25:37 +08:00
string format(format-string<Args...> fmt, Args&&... args);
[libc++][format] Implement formatters. This implements the initial version of the `std::formatter` class and its specializations. It also implements the following formatting functions: - `format` - `vformat` - `format_to` - `vformat_to` - `format_to_n` - `formatted_size` All functions have a `char` and `wchar_t` version. Parsing the format-spec and using the parsed format-spec hasn't been implemented. The code isn't optimized, neither for speed, nor for size. The goal is to have the rudimentary basics working, which can be used as a basis to improve upon. The formatters used in this commit are simple stubs that will be replaced by real formatters in later commits. The formatters that are slated to be replaced in this patch series don't have an availability macro to avoid merge conflicts. Note the formatter for `bool` uses `0` and `1` instead of "false" and "true". This will be fixed when the stub is replaced with a real formatter. Implements parts of: - P0645 Text Formatting Completes: - LWG3539 format_to must not copy models of output_iterator<const charT&> Reviewed By: ldionne, #libc, vitaut Differential Revision: https://reviews.llvm.org/D96664
2020-12-19 20:52:07 +08:00
template<class... Args>
[libc++][format] Use forwarding references. This implements a not accepted LWG issue. Not doing so would require integral types to use the handle class instead of being directly stored in the basic_format_arg. The previous code used `std::forward` in places where it wasn't required by the Standard. These are now removed. Implements: - P2418R2 Add support for std::generator-like types to std::format - LWG 3631 basic_format_arg(T&&) should use remove_cvref_t<T> throughout Reviewed By: ldionne, #libc Differential Revision: https://reviews.llvm.org/D127570
2021-10-06 01:25:37 +08:00
wstring format(wformat-string<Args...> fmt, Args&&... args);
[libc++][format] Implement formatters. This implements the initial version of the `std::formatter` class and its specializations. It also implements the following formatting functions: - `format` - `vformat` - `format_to` - `vformat_to` - `format_to_n` - `formatted_size` All functions have a `char` and `wchar_t` version. Parsing the format-spec and using the parsed format-spec hasn't been implemented. The code isn't optimized, neither for speed, nor for size. The goal is to have the rudimentary basics working, which can be used as a basis to improve upon. The formatters used in this commit are simple stubs that will be replaced by real formatters in later commits. The formatters that are slated to be replaced in this patch series don't have an availability macro to avoid merge conflicts. Note the formatter for `bool` uses `0` and `1` instead of "false" and "true". This will be fixed when the stub is replaced with a real formatter. Implements parts of: - P0645 Text Formatting Completes: - LWG3539 format_to must not copy models of output_iterator<const charT&> Reviewed By: ldionne, #libc, vitaut Differential Revision: https://reviews.llvm.org/D96664
2020-12-19 20:52:07 +08:00
template<class... Args>
[libc++][format] Use forwarding references. This implements a not accepted LWG issue. Not doing so would require integral types to use the handle class instead of being directly stored in the basic_format_arg. The previous code used `std::forward` in places where it wasn't required by the Standard. These are now removed. Implements: - P2418R2 Add support for std::generator-like types to std::format - LWG 3631 basic_format_arg(T&&) should use remove_cvref_t<T> throughout Reviewed By: ldionne, #libc Differential Revision: https://reviews.llvm.org/D127570
2021-10-06 01:25:37 +08:00
string format(const locale& loc, format-string<Args...> fmt, Args&&... args);
[libc++][format] Implement formatters. This implements the initial version of the `std::formatter` class and its specializations. It also implements the following formatting functions: - `format` - `vformat` - `format_to` - `vformat_to` - `format_to_n` - `formatted_size` All functions have a `char` and `wchar_t` version. Parsing the format-spec and using the parsed format-spec hasn't been implemented. The code isn't optimized, neither for speed, nor for size. The goal is to have the rudimentary basics working, which can be used as a basis to improve upon. The formatters used in this commit are simple stubs that will be replaced by real formatters in later commits. The formatters that are slated to be replaced in this patch series don't have an availability macro to avoid merge conflicts. Note the formatter for `bool` uses `0` and `1` instead of "false" and "true". This will be fixed when the stub is replaced with a real formatter. Implements parts of: - P0645 Text Formatting Completes: - LWG3539 format_to must not copy models of output_iterator<const charT&> Reviewed By: ldionne, #libc, vitaut Differential Revision: https://reviews.llvm.org/D96664
2020-12-19 20:52:07 +08:00
template<class... Args>
[libc++][format] Use forwarding references. This implements a not accepted LWG issue. Not doing so would require integral types to use the handle class instead of being directly stored in the basic_format_arg. The previous code used `std::forward` in places where it wasn't required by the Standard. These are now removed. Implements: - P2418R2 Add support for std::generator-like types to std::format - LWG 3631 basic_format_arg(T&&) should use remove_cvref_t<T> throughout Reviewed By: ldionne, #libc Differential Revision: https://reviews.llvm.org/D127570
2021-10-06 01:25:37 +08:00
wstring format(const locale& loc, wformat-string<Args...> fmt, Args&&... args);
[libc++][format] Implement formatters. This implements the initial version of the `std::formatter` class and its specializations. It also implements the following formatting functions: - `format` - `vformat` - `format_to` - `vformat_to` - `format_to_n` - `formatted_size` All functions have a `char` and `wchar_t` version. Parsing the format-spec and using the parsed format-spec hasn't been implemented. The code isn't optimized, neither for speed, nor for size. The goal is to have the rudimentary basics working, which can be used as a basis to improve upon. The formatters used in this commit are simple stubs that will be replaced by real formatters in later commits. The formatters that are slated to be replaced in this patch series don't have an availability macro to avoid merge conflicts. Note the formatter for `bool` uses `0` and `1` instead of "false" and "true". This will be fixed when the stub is replaced with a real formatter. Implements parts of: - P0645 Text Formatting Completes: - LWG3539 format_to must not copy models of output_iterator<const charT&> Reviewed By: ldionne, #libc, vitaut Differential Revision: https://reviews.llvm.org/D96664
2020-12-19 20:52:07 +08:00
string vformat(string_view fmt, format_args args);
wstring vformat(wstring_view fmt, wformat_args args);
string vformat(const locale& loc, string_view fmt, format_args args);
wstring vformat(const locale& loc, wstring_view fmt, wformat_args args);
template<class Out, class... Args>
[libc++][format] Use forwarding references. This implements a not accepted LWG issue. Not doing so would require integral types to use the handle class instead of being directly stored in the basic_format_arg. The previous code used `std::forward` in places where it wasn't required by the Standard. These are now removed. Implements: - P2418R2 Add support for std::generator-like types to std::format - LWG 3631 basic_format_arg(T&&) should use remove_cvref_t<T> throughout Reviewed By: ldionne, #libc Differential Revision: https://reviews.llvm.org/D127570
2021-10-06 01:25:37 +08:00
Out format_to(Out out, format-string<Args...> fmt, Args&&... args);
[libc++][format] Implement formatters. This implements the initial version of the `std::formatter` class and its specializations. It also implements the following formatting functions: - `format` - `vformat` - `format_to` - `vformat_to` - `format_to_n` - `formatted_size` All functions have a `char` and `wchar_t` version. Parsing the format-spec and using the parsed format-spec hasn't been implemented. The code isn't optimized, neither for speed, nor for size. The goal is to have the rudimentary basics working, which can be used as a basis to improve upon. The formatters used in this commit are simple stubs that will be replaced by real formatters in later commits. The formatters that are slated to be replaced in this patch series don't have an availability macro to avoid merge conflicts. Note the formatter for `bool` uses `0` and `1` instead of "false" and "true". This will be fixed when the stub is replaced with a real formatter. Implements parts of: - P0645 Text Formatting Completes: - LWG3539 format_to must not copy models of output_iterator<const charT&> Reviewed By: ldionne, #libc, vitaut Differential Revision: https://reviews.llvm.org/D96664
2020-12-19 20:52:07 +08:00
template<class Out, class... Args>
[libc++][format] Use forwarding references. This implements a not accepted LWG issue. Not doing so would require integral types to use the handle class instead of being directly stored in the basic_format_arg. The previous code used `std::forward` in places where it wasn't required by the Standard. These are now removed. Implements: - P2418R2 Add support for std::generator-like types to std::format - LWG 3631 basic_format_arg(T&&) should use remove_cvref_t<T> throughout Reviewed By: ldionne, #libc Differential Revision: https://reviews.llvm.org/D127570
2021-10-06 01:25:37 +08:00
Out format_to(Out out, wformat-string<Args...> fmt, Args&&... args);
[libc++][format] Implement formatters. This implements the initial version of the `std::formatter` class and its specializations. It also implements the following formatting functions: - `format` - `vformat` - `format_to` - `vformat_to` - `format_to_n` - `formatted_size` All functions have a `char` and `wchar_t` version. Parsing the format-spec and using the parsed format-spec hasn't been implemented. The code isn't optimized, neither for speed, nor for size. The goal is to have the rudimentary basics working, which can be used as a basis to improve upon. The formatters used in this commit are simple stubs that will be replaced by real formatters in later commits. The formatters that are slated to be replaced in this patch series don't have an availability macro to avoid merge conflicts. Note the formatter for `bool` uses `0` and `1` instead of "false" and "true". This will be fixed when the stub is replaced with a real formatter. Implements parts of: - P0645 Text Formatting Completes: - LWG3539 format_to must not copy models of output_iterator<const charT&> Reviewed By: ldionne, #libc, vitaut Differential Revision: https://reviews.llvm.org/D96664
2020-12-19 20:52:07 +08:00
template<class Out, class... Args>
[libc++][format] Use forwarding references. This implements a not accepted LWG issue. Not doing so would require integral types to use the handle class instead of being directly stored in the basic_format_arg. The previous code used `std::forward` in places where it wasn't required by the Standard. These are now removed. Implements: - P2418R2 Add support for std::generator-like types to std::format - LWG 3631 basic_format_arg(T&&) should use remove_cvref_t<T> throughout Reviewed By: ldionne, #libc Differential Revision: https://reviews.llvm.org/D127570
2021-10-06 01:25:37 +08:00
Out format_to(Out out, const locale& loc, format-string<Args...> fmt, Args&&... args);
[libc++][format] Implement formatters. This implements the initial version of the `std::formatter` class and its specializations. It also implements the following formatting functions: - `format` - `vformat` - `format_to` - `vformat_to` - `format_to_n` - `formatted_size` All functions have a `char` and `wchar_t` version. Parsing the format-spec and using the parsed format-spec hasn't been implemented. The code isn't optimized, neither for speed, nor for size. The goal is to have the rudimentary basics working, which can be used as a basis to improve upon. The formatters used in this commit are simple stubs that will be replaced by real formatters in later commits. The formatters that are slated to be replaced in this patch series don't have an availability macro to avoid merge conflicts. Note the formatter for `bool` uses `0` and `1` instead of "false" and "true". This will be fixed when the stub is replaced with a real formatter. Implements parts of: - P0645 Text Formatting Completes: - LWG3539 format_to must not copy models of output_iterator<const charT&> Reviewed By: ldionne, #libc, vitaut Differential Revision: https://reviews.llvm.org/D96664
2020-12-19 20:52:07 +08:00
template<class Out, class... Args>
[libc++][format] Use forwarding references. This implements a not accepted LWG issue. Not doing so would require integral types to use the handle class instead of being directly stored in the basic_format_arg. The previous code used `std::forward` in places where it wasn't required by the Standard. These are now removed. Implements: - P2418R2 Add support for std::generator-like types to std::format - LWG 3631 basic_format_arg(T&&) should use remove_cvref_t<T> throughout Reviewed By: ldionne, #libc Differential Revision: https://reviews.llvm.org/D127570
2021-10-06 01:25:37 +08:00
Out format_to(Out out, const locale& loc, wformat-string<Args...> fmt, Args&&... args);
[libc++][format] Implement formatters. This implements the initial version of the `std::formatter` class and its specializations. It also implements the following formatting functions: - `format` - `vformat` - `format_to` - `vformat_to` - `format_to_n` - `formatted_size` All functions have a `char` and `wchar_t` version. Parsing the format-spec and using the parsed format-spec hasn't been implemented. The code isn't optimized, neither for speed, nor for size. The goal is to have the rudimentary basics working, which can be used as a basis to improve upon. The formatters used in this commit are simple stubs that will be replaced by real formatters in later commits. The formatters that are slated to be replaced in this patch series don't have an availability macro to avoid merge conflicts. Note the formatter for `bool` uses `0` and `1` instead of "false" and "true". This will be fixed when the stub is replaced with a real formatter. Implements parts of: - P0645 Text Formatting Completes: - LWG3539 format_to must not copy models of output_iterator<const charT&> Reviewed By: ldionne, #libc, vitaut Differential Revision: https://reviews.llvm.org/D96664
2020-12-19 20:52:07 +08:00
template<class Out>
[libc++][format][1/6] Reduce binary size. This removes the `format_args_t` from `<format>` and adjusts the type of the `format_args` for the `vformat_to` overloads. The `format_context` uses a `back_insert_iterator<string>` therefore the new `output_iterator` function uses a `string` as its temporary storage buffer. This isn't ideal. The next patches in this series will improve this. These improvements make it easy to also improve `format_to_n` and `formatted_size`. This addresses P2216 `6. Binary size`. P2216 `5. Compile-time checks` are not part of this change. Implements parts of: - P2216 std::format improvements Depends on D103670 Reviewed By: ldionne, #libc Differential Revision: https://reviews.llvm.org/D110494
2021-09-04 19:26:58 +08:00
Out vformat_to(Out out, string_view fmt, format_args args);
[libc++][format] Implement formatters. This implements the initial version of the `std::formatter` class and its specializations. It also implements the following formatting functions: - `format` - `vformat` - `format_to` - `vformat_to` - `format_to_n` - `formatted_size` All functions have a `char` and `wchar_t` version. Parsing the format-spec and using the parsed format-spec hasn't been implemented. The code isn't optimized, neither for speed, nor for size. The goal is to have the rudimentary basics working, which can be used as a basis to improve upon. The formatters used in this commit are simple stubs that will be replaced by real formatters in later commits. The formatters that are slated to be replaced in this patch series don't have an availability macro to avoid merge conflicts. Note the formatter for `bool` uses `0` and `1` instead of "false" and "true". This will be fixed when the stub is replaced with a real formatter. Implements parts of: - P0645 Text Formatting Completes: - LWG3539 format_to must not copy models of output_iterator<const charT&> Reviewed By: ldionne, #libc, vitaut Differential Revision: https://reviews.llvm.org/D96664
2020-12-19 20:52:07 +08:00
template<class Out>
[libc++][format][1/6] Reduce binary size. This removes the `format_args_t` from `<format>` and adjusts the type of the `format_args` for the `vformat_to` overloads. The `format_context` uses a `back_insert_iterator<string>` therefore the new `output_iterator` function uses a `string` as its temporary storage buffer. This isn't ideal. The next patches in this series will improve this. These improvements make it easy to also improve `format_to_n` and `formatted_size`. This addresses P2216 `6. Binary size`. P2216 `5. Compile-time checks` are not part of this change. Implements parts of: - P2216 std::format improvements Depends on D103670 Reviewed By: ldionne, #libc Differential Revision: https://reviews.llvm.org/D110494
2021-09-04 19:26:58 +08:00
Out vformat_to(Out out, wstring_view fmt, wformat_args args);
[libc++][format] Implement formatters. This implements the initial version of the `std::formatter` class and its specializations. It also implements the following formatting functions: - `format` - `vformat` - `format_to` - `vformat_to` - `format_to_n` - `formatted_size` All functions have a `char` and `wchar_t` version. Parsing the format-spec and using the parsed format-spec hasn't been implemented. The code isn't optimized, neither for speed, nor for size. The goal is to have the rudimentary basics working, which can be used as a basis to improve upon. The formatters used in this commit are simple stubs that will be replaced by real formatters in later commits. The formatters that are slated to be replaced in this patch series don't have an availability macro to avoid merge conflicts. Note the formatter for `bool` uses `0` and `1` instead of "false" and "true". This will be fixed when the stub is replaced with a real formatter. Implements parts of: - P0645 Text Formatting Completes: - LWG3539 format_to must not copy models of output_iterator<const charT&> Reviewed By: ldionne, #libc, vitaut Differential Revision: https://reviews.llvm.org/D96664
2020-12-19 20:52:07 +08:00
template<class Out>
Out vformat_to(Out out, const locale& loc, string_view fmt,
[libc++][format][1/6] Reduce binary size. This removes the `format_args_t` from `<format>` and adjusts the type of the `format_args` for the `vformat_to` overloads. The `format_context` uses a `back_insert_iterator<string>` therefore the new `output_iterator` function uses a `string` as its temporary storage buffer. This isn't ideal. The next patches in this series will improve this. These improvements make it easy to also improve `format_to_n` and `formatted_size`. This addresses P2216 `6. Binary size`. P2216 `5. Compile-time checks` are not part of this change. Implements parts of: - P2216 std::format improvements Depends on D103670 Reviewed By: ldionne, #libc Differential Revision: https://reviews.llvm.org/D110494
2021-09-04 19:26:58 +08:00
format_args char> args);
[libc++][format] Implement formatters. This implements the initial version of the `std::formatter` class and its specializations. It also implements the following formatting functions: - `format` - `vformat` - `format_to` - `vformat_to` - `format_to_n` - `formatted_size` All functions have a `char` and `wchar_t` version. Parsing the format-spec and using the parsed format-spec hasn't been implemented. The code isn't optimized, neither for speed, nor for size. The goal is to have the rudimentary basics working, which can be used as a basis to improve upon. The formatters used in this commit are simple stubs that will be replaced by real formatters in later commits. The formatters that are slated to be replaced in this patch series don't have an availability macro to avoid merge conflicts. Note the formatter for `bool` uses `0` and `1` instead of "false" and "true". This will be fixed when the stub is replaced with a real formatter. Implements parts of: - P0645 Text Formatting Completes: - LWG3539 format_to must not copy models of output_iterator<const charT&> Reviewed By: ldionne, #libc, vitaut Differential Revision: https://reviews.llvm.org/D96664
2020-12-19 20:52:07 +08:00
template<class Out>
Out vformat_to(Out out, const locale& loc, wstring_view fmt,
[libc++][format][1/6] Reduce binary size. This removes the `format_args_t` from `<format>` and adjusts the type of the `format_args` for the `vformat_to` overloads. The `format_context` uses a `back_insert_iterator<string>` therefore the new `output_iterator` function uses a `string` as its temporary storage buffer. This isn't ideal. The next patches in this series will improve this. These improvements make it easy to also improve `format_to_n` and `formatted_size`. This addresses P2216 `6. Binary size`. P2216 `5. Compile-time checks` are not part of this change. Implements parts of: - P2216 std::format improvements Depends on D103670 Reviewed By: ldionne, #libc Differential Revision: https://reviews.llvm.org/D110494
2021-09-04 19:26:58 +08:00
wformat_args args);
[libc++][format] Implement formatters. This implements the initial version of the `std::formatter` class and its specializations. It also implements the following formatting functions: - `format` - `vformat` - `format_to` - `vformat_to` - `format_to_n` - `formatted_size` All functions have a `char` and `wchar_t` version. Parsing the format-spec and using the parsed format-spec hasn't been implemented. The code isn't optimized, neither for speed, nor for size. The goal is to have the rudimentary basics working, which can be used as a basis to improve upon. The formatters used in this commit are simple stubs that will be replaced by real formatters in later commits. The formatters that are slated to be replaced in this patch series don't have an availability macro to avoid merge conflicts. Note the formatter for `bool` uses `0` and `1` instead of "false" and "true". This will be fixed when the stub is replaced with a real formatter. Implements parts of: - P0645 Text Formatting Completes: - LWG3539 format_to must not copy models of output_iterator<const charT&> Reviewed By: ldionne, #libc, vitaut Differential Revision: https://reviews.llvm.org/D96664
2020-12-19 20:52:07 +08:00
template<class Out> struct format_to_n_result {
Out out;
iter_difference_t<Out> size;
};
[libc++][format] Finish P0645 Text Formatting. This adjust the version macro and sets it as completed. All parts of the paper have been implemented, except for the parts replaced by later papers and LWG-issues. Adjusted the synopsis to match the synopsis in the Standard. Not yet implemented parts of P2216 and P2418 still use the P0645 wording. Completes: - P0645 Text Formatting Depends on D115991 Reviewed By: ldionne, #libc Differential Revision: https://reviews.llvm.org/D115999
2021-12-18 22:03:26 +08:00
template<class Out, class... Args>
[libc++][format] Implement formatters. This implements the initial version of the `std::formatter` class and its specializations. It also implements the following formatting functions: - `format` - `vformat` - `format_to` - `vformat_to` - `format_to_n` - `formatted_size` All functions have a `char` and `wchar_t` version. Parsing the format-spec and using the parsed format-spec hasn't been implemented. The code isn't optimized, neither for speed, nor for size. The goal is to have the rudimentary basics working, which can be used as a basis to improve upon. The formatters used in this commit are simple stubs that will be replaced by real formatters in later commits. The formatters that are slated to be replaced in this patch series don't have an availability macro to avoid merge conflicts. Note the formatter for `bool` uses `0` and `1` instead of "false" and "true". This will be fixed when the stub is replaced with a real formatter. Implements parts of: - P0645 Text Formatting Completes: - LWG3539 format_to must not copy models of output_iterator<const charT&> Reviewed By: ldionne, #libc, vitaut Differential Revision: https://reviews.llvm.org/D96664
2020-12-19 20:52:07 +08:00
format_to_n_result<Out> format_to_n(Out out, iter_difference_t<Out> n,
[libc++][format] Use forwarding references. This implements a not accepted LWG issue. Not doing so would require integral types to use the handle class instead of being directly stored in the basic_format_arg. The previous code used `std::forward` in places where it wasn't required by the Standard. These are now removed. Implements: - P2418R2 Add support for std::generator-like types to std::format - LWG 3631 basic_format_arg(T&&) should use remove_cvref_t<T> throughout Reviewed By: ldionne, #libc Differential Revision: https://reviews.llvm.org/D127570
2021-10-06 01:25:37 +08:00
format-string<Args...> fmt, Args&&... args);
[libc++][format] Implement formatters. This implements the initial version of the `std::formatter` class and its specializations. It also implements the following formatting functions: - `format` - `vformat` - `format_to` - `vformat_to` - `format_to_n` - `formatted_size` All functions have a `char` and `wchar_t` version. Parsing the format-spec and using the parsed format-spec hasn't been implemented. The code isn't optimized, neither for speed, nor for size. The goal is to have the rudimentary basics working, which can be used as a basis to improve upon. The formatters used in this commit are simple stubs that will be replaced by real formatters in later commits. The formatters that are slated to be replaced in this patch series don't have an availability macro to avoid merge conflicts. Note the formatter for `bool` uses `0` and `1` instead of "false" and "true". This will be fixed when the stub is replaced with a real formatter. Implements parts of: - P0645 Text Formatting Completes: - LWG3539 format_to must not copy models of output_iterator<const charT&> Reviewed By: ldionne, #libc, vitaut Differential Revision: https://reviews.llvm.org/D96664
2020-12-19 20:52:07 +08:00
template<class Out, class... Args>
format_to_n_result<Out> format_to_n(Out out, iter_difference_t<Out> n,
[libc++][format] Use forwarding references. This implements a not accepted LWG issue. Not doing so would require integral types to use the handle class instead of being directly stored in the basic_format_arg. The previous code used `std::forward` in places where it wasn't required by the Standard. These are now removed. Implements: - P2418R2 Add support for std::generator-like types to std::format - LWG 3631 basic_format_arg(T&&) should use remove_cvref_t<T> throughout Reviewed By: ldionne, #libc Differential Revision: https://reviews.llvm.org/D127570
2021-10-06 01:25:37 +08:00
wformat-string<Args...> fmt, Args&&... args);
[libc++][format] Implement formatters. This implements the initial version of the `std::formatter` class and its specializations. It also implements the following formatting functions: - `format` - `vformat` - `format_to` - `vformat_to` - `format_to_n` - `formatted_size` All functions have a `char` and `wchar_t` version. Parsing the format-spec and using the parsed format-spec hasn't been implemented. The code isn't optimized, neither for speed, nor for size. The goal is to have the rudimentary basics working, which can be used as a basis to improve upon. The formatters used in this commit are simple stubs that will be replaced by real formatters in later commits. The formatters that are slated to be replaced in this patch series don't have an availability macro to avoid merge conflicts. Note the formatter for `bool` uses `0` and `1` instead of "false" and "true". This will be fixed when the stub is replaced with a real formatter. Implements parts of: - P0645 Text Formatting Completes: - LWG3539 format_to must not copy models of output_iterator<const charT&> Reviewed By: ldionne, #libc, vitaut Differential Revision: https://reviews.llvm.org/D96664
2020-12-19 20:52:07 +08:00
template<class Out, class... Args>
format_to_n_result<Out> format_to_n(Out out, iter_difference_t<Out> n,
[libc++][format] Implement format-string. Implements the compile-time checking of the formatting arguments. Completes: - P2216 std::format improvements Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D121530
2021-10-02 18:38:46 +08:00
const locale& loc, format-string<Args...> fmt,
[libc++][format] Use forwarding references. This implements a not accepted LWG issue. Not doing so would require integral types to use the handle class instead of being directly stored in the basic_format_arg. The previous code used `std::forward` in places where it wasn't required by the Standard. These are now removed. Implements: - P2418R2 Add support for std::generator-like types to std::format - LWG 3631 basic_format_arg(T&&) should use remove_cvref_t<T> throughout Reviewed By: ldionne, #libc Differential Revision: https://reviews.llvm.org/D127570
2021-10-06 01:25:37 +08:00
Args&&... args);
[libc++][format] Implement formatters. This implements the initial version of the `std::formatter` class and its specializations. It also implements the following formatting functions: - `format` - `vformat` - `format_to` - `vformat_to` - `format_to_n` - `formatted_size` All functions have a `char` and `wchar_t` version. Parsing the format-spec and using the parsed format-spec hasn't been implemented. The code isn't optimized, neither for speed, nor for size. The goal is to have the rudimentary basics working, which can be used as a basis to improve upon. The formatters used in this commit are simple stubs that will be replaced by real formatters in later commits. The formatters that are slated to be replaced in this patch series don't have an availability macro to avoid merge conflicts. Note the formatter for `bool` uses `0` and `1` instead of "false" and "true". This will be fixed when the stub is replaced with a real formatter. Implements parts of: - P0645 Text Formatting Completes: - LWG3539 format_to must not copy models of output_iterator<const charT&> Reviewed By: ldionne, #libc, vitaut Differential Revision: https://reviews.llvm.org/D96664
2020-12-19 20:52:07 +08:00
template<class Out, class... Args>
format_to_n_result<Out> format_to_n(Out out, iter_difference_t<Out> n,
[libc++][format] Implement format-string. Implements the compile-time checking of the formatting arguments. Completes: - P2216 std::format improvements Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D121530
2021-10-02 18:38:46 +08:00
const locale& loc, wformat-string<Args...> fmt,
[libc++][format] Use forwarding references. This implements a not accepted LWG issue. Not doing so would require integral types to use the handle class instead of being directly stored in the basic_format_arg. The previous code used `std::forward` in places where it wasn't required by the Standard. These are now removed. Implements: - P2418R2 Add support for std::generator-like types to std::format - LWG 3631 basic_format_arg(T&&) should use remove_cvref_t<T> throughout Reviewed By: ldionne, #libc Differential Revision: https://reviews.llvm.org/D127570
2021-10-06 01:25:37 +08:00
Args&&... args);
[libc++][format] Implement formatters. This implements the initial version of the `std::formatter` class and its specializations. It also implements the following formatting functions: - `format` - `vformat` - `format_to` - `vformat_to` - `format_to_n` - `formatted_size` All functions have a `char` and `wchar_t` version. Parsing the format-spec and using the parsed format-spec hasn't been implemented. The code isn't optimized, neither for speed, nor for size. The goal is to have the rudimentary basics working, which can be used as a basis to improve upon. The formatters used in this commit are simple stubs that will be replaced by real formatters in later commits. The formatters that are slated to be replaced in this patch series don't have an availability macro to avoid merge conflicts. Note the formatter for `bool` uses `0` and `1` instead of "false" and "true". This will be fixed when the stub is replaced with a real formatter. Implements parts of: - P0645 Text Formatting Completes: - LWG3539 format_to must not copy models of output_iterator<const charT&> Reviewed By: ldionne, #libc, vitaut Differential Revision: https://reviews.llvm.org/D96664
2020-12-19 20:52:07 +08:00
template<class... Args>
[libc++][format] Use forwarding references. This implements a not accepted LWG issue. Not doing so would require integral types to use the handle class instead of being directly stored in the basic_format_arg. The previous code used `std::forward` in places where it wasn't required by the Standard. These are now removed. Implements: - P2418R2 Add support for std::generator-like types to std::format - LWG 3631 basic_format_arg(T&&) should use remove_cvref_t<T> throughout Reviewed By: ldionne, #libc Differential Revision: https://reviews.llvm.org/D127570
2021-10-06 01:25:37 +08:00
size_t formatted_size(format-string<Args...> fmt, Args&&... args);
[libc++][format] Implement formatters. This implements the initial version of the `std::formatter` class and its specializations. It also implements the following formatting functions: - `format` - `vformat` - `format_to` - `vformat_to` - `format_to_n` - `formatted_size` All functions have a `char` and `wchar_t` version. Parsing the format-spec and using the parsed format-spec hasn't been implemented. The code isn't optimized, neither for speed, nor for size. The goal is to have the rudimentary basics working, which can be used as a basis to improve upon. The formatters used in this commit are simple stubs that will be replaced by real formatters in later commits. The formatters that are slated to be replaced in this patch series don't have an availability macro to avoid merge conflicts. Note the formatter for `bool` uses `0` and `1` instead of "false" and "true". This will be fixed when the stub is replaced with a real formatter. Implements parts of: - P0645 Text Formatting Completes: - LWG3539 format_to must not copy models of output_iterator<const charT&> Reviewed By: ldionne, #libc, vitaut Differential Revision: https://reviews.llvm.org/D96664
2020-12-19 20:52:07 +08:00
template<class... Args>
[libc++][format] Use forwarding references. This implements a not accepted LWG issue. Not doing so would require integral types to use the handle class instead of being directly stored in the basic_format_arg. The previous code used `std::forward` in places where it wasn't required by the Standard. These are now removed. Implements: - P2418R2 Add support for std::generator-like types to std::format - LWG 3631 basic_format_arg(T&&) should use remove_cvref_t<T> throughout Reviewed By: ldionne, #libc Differential Revision: https://reviews.llvm.org/D127570
2021-10-06 01:25:37 +08:00
size_t formatted_size(wformat-string<Args...> fmt, Args&&... args);
[libc++][format] Implement formatters. This implements the initial version of the `std::formatter` class and its specializations. It also implements the following formatting functions: - `format` - `vformat` - `format_to` - `vformat_to` - `format_to_n` - `formatted_size` All functions have a `char` and `wchar_t` version. Parsing the format-spec and using the parsed format-spec hasn't been implemented. The code isn't optimized, neither for speed, nor for size. The goal is to have the rudimentary basics working, which can be used as a basis to improve upon. The formatters used in this commit are simple stubs that will be replaced by real formatters in later commits. The formatters that are slated to be replaced in this patch series don't have an availability macro to avoid merge conflicts. Note the formatter for `bool` uses `0` and `1` instead of "false" and "true". This will be fixed when the stub is replaced with a real formatter. Implements parts of: - P0645 Text Formatting Completes: - LWG3539 format_to must not copy models of output_iterator<const charT&> Reviewed By: ldionne, #libc, vitaut Differential Revision: https://reviews.llvm.org/D96664
2020-12-19 20:52:07 +08:00
template<class... Args>
[libc++][format] Use forwarding references. This implements a not accepted LWG issue. Not doing so would require integral types to use the handle class instead of being directly stored in the basic_format_arg. The previous code used `std::forward` in places where it wasn't required by the Standard. These are now removed. Implements: - P2418R2 Add support for std::generator-like types to std::format - LWG 3631 basic_format_arg(T&&) should use remove_cvref_t<T> throughout Reviewed By: ldionne, #libc Differential Revision: https://reviews.llvm.org/D127570
2021-10-06 01:25:37 +08:00
size_t formatted_size(const locale& loc, format-string<Args...> fmt, Args&&... args);
[libc++][format] Implement formatters. This implements the initial version of the `std::formatter` class and its specializations. It also implements the following formatting functions: - `format` - `vformat` - `format_to` - `vformat_to` - `format_to_n` - `formatted_size` All functions have a `char` and `wchar_t` version. Parsing the format-spec and using the parsed format-spec hasn't been implemented. The code isn't optimized, neither for speed, nor for size. The goal is to have the rudimentary basics working, which can be used as a basis to improve upon. The formatters used in this commit are simple stubs that will be replaced by real formatters in later commits. The formatters that are slated to be replaced in this patch series don't have an availability macro to avoid merge conflicts. Note the formatter for `bool` uses `0` and `1` instead of "false" and "true". This will be fixed when the stub is replaced with a real formatter. Implements parts of: - P0645 Text Formatting Completes: - LWG3539 format_to must not copy models of output_iterator<const charT&> Reviewed By: ldionne, #libc, vitaut Differential Revision: https://reviews.llvm.org/D96664
2020-12-19 20:52:07 +08:00
template<class... Args>
[libc++][format] Use forwarding references. This implements a not accepted LWG issue. Not doing so would require integral types to use the handle class instead of being directly stored in the basic_format_arg. The previous code used `std::forward` in places where it wasn't required by the Standard. These are now removed. Implements: - P2418R2 Add support for std::generator-like types to std::format - LWG 3631 basic_format_arg(T&&) should use remove_cvref_t<T> throughout Reviewed By: ldionne, #libc Differential Revision: https://reviews.llvm.org/D127570
2021-10-06 01:25:37 +08:00
size_t formatted_size(const locale& loc, wformat-string<Args...> fmt, Args&&... args);
[libc++][format] Implement formatters. This implements the initial version of the `std::formatter` class and its specializations. It also implements the following formatting functions: - `format` - `vformat` - `format_to` - `vformat_to` - `format_to_n` - `formatted_size` All functions have a `char` and `wchar_t` version. Parsing the format-spec and using the parsed format-spec hasn't been implemented. The code isn't optimized, neither for speed, nor for size. The goal is to have the rudimentary basics working, which can be used as a basis to improve upon. The formatters used in this commit are simple stubs that will be replaced by real formatters in later commits. The formatters that are slated to be replaced in this patch series don't have an availability macro to avoid merge conflicts. Note the formatter for `bool` uses `0` and `1` instead of "false" and "true". This will be fixed when the stub is replaced with a real formatter. Implements parts of: - P0645 Text Formatting Completes: - LWG3539 format_to must not copy models of output_iterator<const charT&> Reviewed By: ldionne, #libc, vitaut Differential Revision: https://reviews.llvm.org/D96664
2020-12-19 20:52:07 +08:00
// [format.formatter], formatter
[libc++][format] Finish P0645 Text Formatting. This adjust the version macro and sets it as completed. All parts of the paper have been implemented, except for the parts replaced by later papers and LWG-issues. Adjusted the synopsis to match the synopsis in the Standard. Not yet implemented parts of P2216 and P2418 still use the P0645 wording. Completes: - P0645 Text Formatting Depends on D115991 Reviewed By: ldionne, #libc Differential Revision: https://reviews.llvm.org/D115999
2021-12-18 22:03:26 +08:00
template<class T, class charT = char> struct formatter;
[libc++][format] Implement formatters. This implements the initial version of the `std::formatter` class and its specializations. It also implements the following formatting functions: - `format` - `vformat` - `format_to` - `vformat_to` - `format_to_n` - `formatted_size` All functions have a `char` and `wchar_t` version. Parsing the format-spec and using the parsed format-spec hasn't been implemented. The code isn't optimized, neither for speed, nor for size. The goal is to have the rudimentary basics working, which can be used as a basis to improve upon. The formatters used in this commit are simple stubs that will be replaced by real formatters in later commits. The formatters that are slated to be replaced in this patch series don't have an availability macro to avoid merge conflicts. Note the formatter for `bool` uses `0` and `1` instead of "false" and "true". This will be fixed when the stub is replaced with a real formatter. Implements parts of: - P0645 Text Formatting Completes: - LWG3539 format_to must not copy models of output_iterator<const charT&> Reviewed By: ldionne, #libc, vitaut Differential Revision: https://reviews.llvm.org/D96664
2020-12-19 20:52:07 +08:00
[libc++][format] Add __format_arg_store. This implements the struct `__format_arg_store` and its dependencies: * the class basic_format_arg, * the class basic_format_args, * the class basic_format_context, * the function make_format_args, * the function wmake_format_args, * the function visit_format_arg, * several Standard required typedefs. The following parts will be implemented in a later patch: * the child class `basic_format_arg::handle`, * the function `basic_format_arg::basic_format_arg(const T* p)`. The following extension has been implemented: * the class basic_format_arg supports `__[u]int128_t` on platform where libc++ supports 128 bit integrals. Implements parts of: * P0645 Text Formatting Completes: * LWG3371 visit_format_arg and make_format_args are not hidden friends * LWG3542 basic_format_arg mishandles basic_string_view with custom traits Note https://mordante.github.io/blog/2021/06/05/format.html gives a bit more information about the goals and non-goals of this initial patch series. Reviewed By: #libc, ldionne, vitaut Differential Revision: https://reviews.llvm.org/D103357
2020-12-05 18:45:21 +08:00
// [format.parse.ctx], class template basic_format_parse_context
[libc++][format] Finish P0645 Text Formatting. This adjust the version macro and sets it as completed. All parts of the paper have been implemented, except for the parts replaced by later papers and LWG-issues. Adjusted the synopsis to match the synopsis in the Standard. Not yet implemented parts of P2216 and P2418 still use the P0645 wording. Completes: - P0645 Text Formatting Depends on D115991 Reviewed By: ldionne, #libc Differential Revision: https://reviews.llvm.org/D115999
2021-12-18 22:03:26 +08:00
template<class charT> class basic_format_parse_context;
[libc++][format] Add __format_arg_store. This implements the struct `__format_arg_store` and its dependencies: * the class basic_format_arg, * the class basic_format_args, * the class basic_format_context, * the function make_format_args, * the function wmake_format_args, * the function visit_format_arg, * several Standard required typedefs. The following parts will be implemented in a later patch: * the child class `basic_format_arg::handle`, * the function `basic_format_arg::basic_format_arg(const T* p)`. The following extension has been implemented: * the class basic_format_arg supports `__[u]int128_t` on platform where libc++ supports 128 bit integrals. Implements parts of: * P0645 Text Formatting Completes: * LWG3371 visit_format_arg and make_format_args are not hidden friends * LWG3542 basic_format_arg mishandles basic_string_view with custom traits Note https://mordante.github.io/blog/2021/06/05/format.html gives a bit more information about the goals and non-goals of this initial patch series. Reviewed By: #libc, ldionne, vitaut Differential Revision: https://reviews.llvm.org/D103357
2020-12-05 18:45:21 +08:00
using format_parse_context = basic_format_parse_context<char>;
using wformat_parse_context = basic_format_parse_context<wchar_t>;
// [format.arguments], arguments
// [format.arg], class template basic_format_arg
[libc++][format] Finish P0645 Text Formatting. This adjust the version macro and sets it as completed. All parts of the paper have been implemented, except for the parts replaced by later papers and LWG-issues. Adjusted the synopsis to match the synopsis in the Standard. Not yet implemented parts of P2216 and P2418 still use the P0645 wording. Completes: - P0645 Text Formatting Depends on D115991 Reviewed By: ldionne, #libc Differential Revision: https://reviews.llvm.org/D115999
2021-12-18 22:03:26 +08:00
template<class Context> class basic_format_arg;
[libc++][format] Add __format_arg_store. This implements the struct `__format_arg_store` and its dependencies: * the class basic_format_arg, * the class basic_format_args, * the class basic_format_context, * the function make_format_args, * the function wmake_format_args, * the function visit_format_arg, * several Standard required typedefs. The following parts will be implemented in a later patch: * the child class `basic_format_arg::handle`, * the function `basic_format_arg::basic_format_arg(const T* p)`. The following extension has been implemented: * the class basic_format_arg supports `__[u]int128_t` on platform where libc++ supports 128 bit integrals. Implements parts of: * P0645 Text Formatting Completes: * LWG3371 visit_format_arg and make_format_args are not hidden friends * LWG3542 basic_format_arg mishandles basic_string_view with custom traits Note https://mordante.github.io/blog/2021/06/05/format.html gives a bit more information about the goals and non-goals of this initial patch series. Reviewed By: #libc, ldionne, vitaut Differential Revision: https://reviews.llvm.org/D103357
2020-12-05 18:45:21 +08:00
template<class Visitor, class Context>
see below visit_format_arg(Visitor&& vis, basic_format_arg<Context> arg);
// [format.arg.store], class template format-arg-store
[libc++][format] Finish P0645 Text Formatting. This adjust the version macro and sets it as completed. All parts of the paper have been implemented, except for the parts replaced by later papers and LWG-issues. Adjusted the synopsis to match the synopsis in the Standard. Not yet implemented parts of P2216 and P2418 still use the P0645 wording. Completes: - P0645 Text Formatting Depends on D115991 Reviewed By: ldionne, #libc Differential Revision: https://reviews.llvm.org/D115999
2021-12-18 22:03:26 +08:00
template<class Context, class... Args> struct format-arg-store; // exposition only
[libc++][format] Add __format_arg_store. This implements the struct `__format_arg_store` and its dependencies: * the class basic_format_arg, * the class basic_format_args, * the class basic_format_context, * the function make_format_args, * the function wmake_format_args, * the function visit_format_arg, * several Standard required typedefs. The following parts will be implemented in a later patch: * the child class `basic_format_arg::handle`, * the function `basic_format_arg::basic_format_arg(const T* p)`. The following extension has been implemented: * the class basic_format_arg supports `__[u]int128_t` on platform where libc++ supports 128 bit integrals. Implements parts of: * P0645 Text Formatting Completes: * LWG3371 visit_format_arg and make_format_args are not hidden friends * LWG3542 basic_format_arg mishandles basic_string_view with custom traits Note https://mordante.github.io/blog/2021/06/05/format.html gives a bit more information about the goals and non-goals of this initial patch series. Reviewed By: #libc, ldionne, vitaut Differential Revision: https://reviews.llvm.org/D103357
2020-12-05 18:45:21 +08:00
template<class Context = format_context, class... Args>
format-arg-store<Context, Args...>
[libc++][format] Use forwarding references. This implements a not accepted LWG issue. Not doing so would require integral types to use the handle class instead of being directly stored in the basic_format_arg. The previous code used `std::forward` in places where it wasn't required by the Standard. These are now removed. Implements: - P2418R2 Add support for std::generator-like types to std::format - LWG 3631 basic_format_arg(T&&) should use remove_cvref_t<T> throughout Reviewed By: ldionne, #libc Differential Revision: https://reviews.llvm.org/D127570
2021-10-06 01:25:37 +08:00
make_format_args(Args&&... args);
[libc++][format] Add __format_arg_store. This implements the struct `__format_arg_store` and its dependencies: * the class basic_format_arg, * the class basic_format_args, * the class basic_format_context, * the function make_format_args, * the function wmake_format_args, * the function visit_format_arg, * several Standard required typedefs. The following parts will be implemented in a later patch: * the child class `basic_format_arg::handle`, * the function `basic_format_arg::basic_format_arg(const T* p)`. The following extension has been implemented: * the class basic_format_arg supports `__[u]int128_t` on platform where libc++ supports 128 bit integrals. Implements parts of: * P0645 Text Formatting Completes: * LWG3371 visit_format_arg and make_format_args are not hidden friends * LWG3542 basic_format_arg mishandles basic_string_view with custom traits Note https://mordante.github.io/blog/2021/06/05/format.html gives a bit more information about the goals and non-goals of this initial patch series. Reviewed By: #libc, ldionne, vitaut Differential Revision: https://reviews.llvm.org/D103357
2020-12-05 18:45:21 +08:00
template<class... Args>
format-arg-store<wformat_context, Args...>
[libc++][format] Use forwarding references. This implements a not accepted LWG issue. Not doing so would require integral types to use the handle class instead of being directly stored in the basic_format_arg. The previous code used `std::forward` in places where it wasn't required by the Standard. These are now removed. Implements: - P2418R2 Add support for std::generator-like types to std::format - LWG 3631 basic_format_arg(T&&) should use remove_cvref_t<T> throughout Reviewed By: ldionne, #libc Differential Revision: https://reviews.llvm.org/D127570
2021-10-06 01:25:37 +08:00
make_wformat_args(Args&&... args);
[libc++][format] Add __format_arg_store. This implements the struct `__format_arg_store` and its dependencies: * the class basic_format_arg, * the class basic_format_args, * the class basic_format_context, * the function make_format_args, * the function wmake_format_args, * the function visit_format_arg, * several Standard required typedefs. The following parts will be implemented in a later patch: * the child class `basic_format_arg::handle`, * the function `basic_format_arg::basic_format_arg(const T* p)`. The following extension has been implemented: * the class basic_format_arg supports `__[u]int128_t` on platform where libc++ supports 128 bit integrals. Implements parts of: * P0645 Text Formatting Completes: * LWG3371 visit_format_arg and make_format_args are not hidden friends * LWG3542 basic_format_arg mishandles basic_string_view with custom traits Note https://mordante.github.io/blog/2021/06/05/format.html gives a bit more information about the goals and non-goals of this initial patch series. Reviewed By: #libc, ldionne, vitaut Differential Revision: https://reviews.llvm.org/D103357
2020-12-05 18:45:21 +08:00
[libc++] Implement format_error. This is the first step at implementing <format>. It adds the <format> header and implements the `format_error`. class. Implemnts parts of: -P0645 Text Formatting Reviewed By: ldionne, #libc, miscco, curdeius Differential Revision: https://reviews.llvm.org/D92214
2020-11-27 02:12:18 +08:00
// [format.error], class format_error
[libc++][format] Finish P0645 Text Formatting. This adjust the version macro and sets it as completed. All parts of the paper have been implemented, except for the parts replaced by later papers and LWG-issues. Adjusted the synopsis to match the synopsis in the Standard. Not yet implemented parts of P2216 and P2418 still use the P0645 wording. Completes: - P0645 Text Formatting Depends on D115991 Reviewed By: ldionne, #libc Differential Revision: https://reviews.llvm.org/D115999
2021-12-18 22:03:26 +08:00
class format_error;
[libc++] Implement format_error. This is the first step at implementing <format>. It adds the <format> header and implements the `format_error`. class. Implemnts parts of: -P0645 Text Formatting Reviewed By: ldionne, #libc, miscco, curdeius Differential Revision: https://reviews.llvm.org/D92214
2020-11-27 02:12:18 +08:00
}
*/
[libc++] Ensure that all public C++ headers include <__assert> This patch changes the requirement for getting the declaration of the assertion handler from including <__assert> to including any public C++ header of the library. Note that C compatibility headers are excluded because we don't implement all the C headers ourselves -- some of them are taken straight from the C library, like assert.h. It also adds a generated test to check it. Furthermore, this new generated test is designed in a way that will make it possible to replace almost all the existing test-generation scripts with this system in upcoming patches. Differential Revision: https://reviews.llvm.org/D122506
2022-03-26 00:55:36 +08:00
#include <__assert> // all public C++ headers provide the assertion handler
[libc++][doc] Improve contributor documentation. Addresses the post-commit review comments of D107596.
2021-08-11 23:33:54 +08:00
// Make sure all feature-test macros are available.
[libc++] Improve LIBCXX_ENABLE_INCOMPLETE_FEATURES. @tcanens pointed out the current behavior of the macro breaks the usage pattern described in http://wg21.link/SD6 ``` # if __has_include(<optional>) # include <optional> # if __cpp_lib_optional >= 201606 # define have_optional 1 # endif ``` To support this usage pattern the hard errror is removed. Instead the header includes nothing but the `<version>` header. Reviewed By: ldionne, #libc Differential Revision: https://reviews.llvm.org/D107134
2021-07-31 02:35:37 +08:00
#include <version>
[libc++][doc] Improve contributor documentation. Addresses the post-commit review comments of D107596.
2021-08-11 23:33:54 +08:00
// Enable the contents of the header only when libc++ was built with LIBCXX_ENABLE_INCOMPLETE_FEATURES.
[libc++] Improve LIBCXX_ENABLE_INCOMPLETE_FEATURES. @tcanens pointed out the current behavior of the macro breaks the usage pattern described in http://wg21.link/SD6 ``` # if __has_include(<optional>) # include <optional> # if __cpp_lib_optional >= 201606 # define have_optional 1 # endif ``` To support this usage pattern the hard errror is removed. Instead the header includes nothing but the `<version>` header. Reviewed By: ldionne, #libc Differential Revision: https://reviews.llvm.org/D107134
2021-07-31 02:35:37 +08:00
#if !defined(_LIBCPP_HAS_NO_INCOMPLETE_FORMAT)
[libc++] Granularize algorithm includes Reviewed By: Mordante, ldionne, Quuxplusone, #libc, #libc_abi Spies: #libc_vendors, libcxx-commits, miyuki Differential Revision: https://reviews.llvm.org/D119667
2022-02-16 01:18:08 +08:00
#include <__algorithm/clamp.h>
[libc++] Implement format_error. This is the first step at implementing <format>. It adds the <format> header and implements the `format_error`. class. Implemnts parts of: -P0645 Text Formatting Reviewed By: ldionne, #libc, miscco, curdeius Differential Revision: https://reviews.llvm.org/D92214
2020-11-27 02:12:18 +08:00
#include <__config>
[libc++][format] Implement formatters. This implements the initial version of the `std::formatter` class and its specializations. It also implements the following formatting functions: - `format` - `vformat` - `format_to` - `vformat_to` - `format_to_n` - `formatted_size` All functions have a `char` and `wchar_t` version. Parsing the format-spec and using the parsed format-spec hasn't been implemented. The code isn't optimized, neither for speed, nor for size. The goal is to have the rudimentary basics working, which can be used as a basis to improve upon. The formatters used in this commit are simple stubs that will be replaced by real formatters in later commits. The formatters that are slated to be replaced in this patch series don't have an availability macro to avoid merge conflicts. Note the formatter for `bool` uses `0` and `1` instead of "false" and "true". This will be fixed when the stub is replaced with a real formatter. Implements parts of: - P0645 Text Formatting Completes: - LWG3539 format_to must not copy models of output_iterator<const charT&> Reviewed By: ldionne, #libc, vitaut Differential Revision: https://reviews.llvm.org/D96664
2020-12-19 20:52:07 +08:00
#include <__debug>
[libc++][format][2/6] Adds a __output_iterator. Instead of using a temporary `string` in `__vformat_to_wrapped` use a new generic iterator. This aids to reduce the number of template instantions and avoids using a `string` to buffer the entire formatted output. This changes the type of `format_context` and `wformat_context`, this can still be done since the code isn't ABI stable yet. Several approaches have been evaluated: - Using a __output_buffer base class with: - a put function to store the buffer in its internal buffer - a virtual flush function to copy the internal buffer to the output - Using a `function` to forward the output operation to the output buffer, much like the next method. - Using a type erased function point to store the data in the buffer. The last version resulted in the best performance. For some cases there's still a loss of speed over the original method. This loss many becomes apparent when large strings are copied to a pointer like iterator, before the compiler optimized this using `memcpy`. Reviewed By: ldionne, vitaut, #libc Differential Revision: https://reviews.llvm.org/D110495
2021-09-05 03:05:23 +08:00
#include <__format/buffer.h>
[libc++][format] Adds a formattable concept. The concept is based on P2286R2 Formatting Ranges. It will be used to optimise the storage of __format_arg_store as required by LWG-3473. Depends on D120916 Reviewed By: #libc, Mordante Differential Revision: https://reviews.llvm.org/D120921
2022-01-30 23:08:19 +08:00
#include <__format/concepts.h>
[libc++][format][3/6] Adds a __container_buffer. Instead of writing every character directly into the container by using a `back_insert_iterator` the data is buffered in an `array`. This buffer is then inserted to the container by calling its `insert` member function. Since there's no guarantee every container's `insert` behaves properly containers need to opt-in to this behaviour. The appropriate standard containers opt-in to this behaviour. This change improves the performance of the format functions that use a `back_insert_iterator`. Depends on D110495 Reviewed By: ldionne, vitaut, #libc Differential Revision: https://reviews.llvm.org/D110497
2021-09-26 21:47:42 +08:00
#include <__format/enable_insertable.h>
[libc++][format] Add __format_arg_store. This implements the struct `__format_arg_store` and its dependencies: * the class basic_format_arg, * the class basic_format_args, * the class basic_format_context, * the function make_format_args, * the function wmake_format_args, * the function visit_format_arg, * several Standard required typedefs. The following parts will be implemented in a later patch: * the child class `basic_format_arg::handle`, * the function `basic_format_arg::basic_format_arg(const T* p)`. The following extension has been implemented: * the class basic_format_arg supports `__[u]int128_t` on platform where libc++ supports 128 bit integrals. Implements parts of: * P0645 Text Formatting Completes: * LWG3371 visit_format_arg and make_format_args are not hidden friends * LWG3542 basic_format_arg mishandles basic_string_view with custom traits Note https://mordante.github.io/blog/2021/06/05/format.html gives a bit more information about the goals and non-goals of this initial patch series. Reviewed By: #libc, ldionne, vitaut Differential Revision: https://reviews.llvm.org/D103357
2020-12-05 18:45:21 +08:00
#include <__format/format_arg.h>
[libc++][format] Improve format-arg-store. This optimizes the __format_arg_store type to allow a more efficient storage of the basic_format_args. It stores the data in two arrays: - A struct with the tag of the exposition only variant's type and the offset of the element in the data array. Since this array only depends on the type information it's calculated at compile time and can be shared by different instances of this class. - The arguments converted to the types used in the exposition only variant of basic_format_arg. This means the packed data can be directly copied to an element of this variant. The new code uses rvalue reference arguments in preparation for P2418. The handle class also has some changes to prepare for P2418. The real changed for P2418 will be done separately, but these parts make it easier to implement that paper. Some parts of existing test code are removed since they were no longer valid after the changes, but new tests have been added. Implements parts of: - P2418 Add support for std::generator-like types to std::format Completes: - LWG3473 Normative encouragement in non-normative note Depends on D121138 Reviewed By: #libc, vitaut, Mordante Differential Revision: https://reviews.llvm.org/D121514
2021-10-03 19:11:53 +08:00
#include <__format/format_arg_store.h>
[libc++][format] Add __format_arg_store. This implements the struct `__format_arg_store` and its dependencies: * the class basic_format_arg, * the class basic_format_args, * the class basic_format_context, * the function make_format_args, * the function wmake_format_args, * the function visit_format_arg, * several Standard required typedefs. The following parts will be implemented in a later patch: * the child class `basic_format_arg::handle`, * the function `basic_format_arg::basic_format_arg(const T* p)`. The following extension has been implemented: * the class basic_format_arg supports `__[u]int128_t` on platform where libc++ supports 128 bit integrals. Implements parts of: * P0645 Text Formatting Completes: * LWG3371 visit_format_arg and make_format_args are not hidden friends * LWG3542 basic_format_arg mishandles basic_string_view with custom traits Note https://mordante.github.io/blog/2021/06/05/format.html gives a bit more information about the goals and non-goals of this initial patch series. Reviewed By: #libc, ldionne, vitaut Differential Revision: https://reviews.llvm.org/D103357
2020-12-05 18:45:21 +08:00
#include <__format/format_args.h>
#include <__format/format_context.h>
[libc++][NFC] Move format_error to its own header. Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D101723
2021-04-25 23:58:03 +08:00
#include <__format/format_error.h>
[libc++][format] Adds integer formatter. Implements the formatter for all fundamental integer types (except `char`, `wchar_t`, and `bool`). [format.formatter.spec]/2.3 For each charT, for each cv-unqualified arithmetic type ArithmeticT other than char, wchar_t, char8_t, char16_t, or char32_t, a specialization ``` template<> struct formatter<ArithmeticT, charT>; ``` This removes the stub implemented in D96664. As an extension it adds partial support for 128-bit integer types. Implements parts of: - P0645 Text Formatting - P1652 Printf corner cases in std::format Completes: - LWG-3248 #b, #B, #o, #x, and #X presentation types misformat negative numbers Reviewed By: #libc, ldionne, vitaut Differential Revision: https://reviews.llvm.org/D103433
2020-12-15 00:39:15 +08:00
#include <__format/format_fwd.h>
[libc++][NFC] Move basic_format_parse_context to its own header. This is a preparation to split the format header in smaller parts for the upcoming patches. Depends on D101723 Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D102703
2021-04-26 00:23:42 +08:00
#include <__format/format_parse_context.h>
[libc++][format] Implement formatters. This implements the initial version of the `std::formatter` class and its specializations. It also implements the following formatting functions: - `format` - `vformat` - `format_to` - `vformat_to` - `format_to_n` - `formatted_size` All functions have a `char` and `wchar_t` version. Parsing the format-spec and using the parsed format-spec hasn't been implemented. The code isn't optimized, neither for speed, nor for size. The goal is to have the rudimentary basics working, which can be used as a basis to improve upon. The formatters used in this commit are simple stubs that will be replaced by real formatters in later commits. The formatters that are slated to be replaced in this patch series don't have an availability macro to avoid merge conflicts. Note the formatter for `bool` uses `0` and `1` instead of "false" and "true". This will be fixed when the stub is replaced with a real formatter. Implements parts of: - P0645 Text Formatting Completes: - LWG3539 format_to must not copy models of output_iterator<const charT&> Reviewed By: ldionne, #libc, vitaut Differential Revision: https://reviews.llvm.org/D96664
2020-12-19 20:52:07 +08:00
#include <__format/format_string.h>
[libc++][NFC] Move format_to_n_result. Places `format_to_n_result` to its own file. While working on D112361 it turns out the type will be used outside the format header. Reviewed By: #libc, Quuxplusone, Mordante Differential Revision: https://reviews.llvm.org/D113831
2021-11-14 02:43:32 +08:00
#include <__format/format_to_n_result.h>
[libc++][format] Implement formatters. This implements the initial version of the `std::formatter` class and its specializations. It also implements the following formatting functions: - `format` - `vformat` - `format_to` - `vformat_to` - `format_to_n` - `formatted_size` All functions have a `char` and `wchar_t` version. Parsing the format-spec and using the parsed format-spec hasn't been implemented. The code isn't optimized, neither for speed, nor for size. The goal is to have the rudimentary basics working, which can be used as a basis to improve upon. The formatters used in this commit are simple stubs that will be replaced by real formatters in later commits. The formatters that are slated to be replaced in this patch series don't have an availability macro to avoid merge conflicts. Note the formatter for `bool` uses `0` and `1` instead of "false" and "true". This will be fixed when the stub is replaced with a real formatter. Implements parts of: - P0645 Text Formatting Completes: - LWG3539 format_to must not copy models of output_iterator<const charT&> Reviewed By: ldionne, #libc, vitaut Differential Revision: https://reviews.llvm.org/D96664
2020-12-19 20:52:07 +08:00
#include <__format/formatter.h>
[libc++][format] Adds bool formatter. Implements the formatter for Boolean types. [format.formatter.spec]/2.3 For each charT, for each cv-unqualified arithmetic type ArithmeticT other than char, wchar_t, char8_t, char16_t, or char32_t, a specialization ``` template<> struct formatter<ArithmeticT, charT>; ``` This removes the stub implemented in D96664. Implements parts of: - P0645 Text Formatting - P1652 Printf corner cases in std::format Completes: - P1868 width: clarifying units of width and precision in std::format Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D103670
2020-12-15 00:39:15 +08:00
#include <__format/formatter_bool.h>
[libc++][format] Adds char formatter. Implements the formatter for all fundamental integer types. [format.formatter.spec]/2.1 The specializations ``` template<> struct formatter<char, char>; template<> struct formatter<char, wchar_t>; template<> struct formatter<wchar_t, wchar_t>; ``` This removes the stub implemented in D96664. Implements parts of: - P0645 Text Formatting Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D103466
2020-12-15 00:39:15 +08:00
#include <__format/formatter_char.h>
[libc++][format] Adds formatter floating-point. This properly implements the formatter for floating-point types. Completes: - P1652R1 Printf corner cases in std::format - LWG 3250 std::format: # (alternate form) for NaN and inf - LWG 3243 std::format and negative zeroes Implements parts of: - P0645 Text Formatting Reviewed By: #libc, ldionne, vitaut Differential Revision: https://reviews.llvm.org/D114001
2020-12-15 00:39:15 +08:00
#include <__format/formatter_floating_point.h>
[libc++][format] Adds integer formatter. Implements the formatter for all fundamental integer types (except `char`, `wchar_t`, and `bool`). [format.formatter.spec]/2.3 For each charT, for each cv-unqualified arithmetic type ArithmeticT other than char, wchar_t, char8_t, char16_t, or char32_t, a specialization ``` template<> struct formatter<ArithmeticT, charT>; ``` This removes the stub implemented in D96664. As an extension it adds partial support for 128-bit integer types. Implements parts of: - P0645 Text Formatting - P1652 Printf corner cases in std::format Completes: - LWG-3248 #b, #B, #o, #x, and #X presentation types misformat negative numbers Reviewed By: #libc, ldionne, vitaut Differential Revision: https://reviews.llvm.org/D103433
2020-12-15 00:39:15 +08:00
#include <__format/formatter_integer.h>
[libc++][format] Adds formatter pointer. This implements the last required formatter specialization. Completes: - LWG 3251 Are std::format alignment specifiers applied to string arguments? - LWG 3340 Formatting functions should throw on argument/format string mismatch in §[format.functions] - LWG 3540 §[format.arg] There should be no const in basic_format_arg(const T* p) Implements parts of: - P0645 Text Formatting Depends on D114001 Reviewed By: ldionne, vitaut, #libc Differential Revision: https://reviews.llvm.org/D115988
2021-11-28 21:43:43 +08:00
#include <__format/formatter_pointer.h>
[libc++][format] Adds string formatter. Implements the formatter for all string types. [format.formatter.spec]/2.2 For each charT, the string type specializations ``` template<> struct formatter<charT*, charT>; template<> struct formatter<const charT*, charT>; template<size_t N> struct formatter<const charT[N], charT>; template<class traits, class Allocator> struct formatter<basic_string<charT, traits, Allocator>, charT>; template<class traits> struct formatter<basic_string_view<charT, traits>, charT>; ``` This removes the stub implemented in D96664. Implements parts of: - P0645 Text Formatting - P1868 width: clarifying units of width and precision in std::format Reviewed By: #libc, ldionne, vitaut Differential Revision: https://reviews.llvm.org/D103425
2020-12-15 00:39:15 +08:00
#include <__format/formatter_string.h>
#include <__format/parser_std_format_spec.h>
[libc++] Removes unneeded <iterator> includes. Reviewed By: #libc, philnik Differential Revision: https://reviews.llvm.org/D127675
2022-06-14 02:05:36 +08:00
#include <__iterator/back_insert_iterator.h>
[libc++] Granularize <iterator> includes Reviewed By: ldionne, #libc Spies: libcxx-commits, wenlei Differential Revision: https://reviews.llvm.org/D127445
2022-06-11 01:53:10 +08:00
#include <__iterator/incrementable_traits.h>
[libc++][format] Implement formatters. This implements the initial version of the `std::formatter` class and its specializations. It also implements the following formatting functions: - `format` - `vformat` - `format_to` - `vformat_to` - `format_to_n` - `formatted_size` All functions have a `char` and `wchar_t` version. Parsing the format-spec and using the parsed format-spec hasn't been implemented. The code isn't optimized, neither for speed, nor for size. The goal is to have the rudimentary basics working, which can be used as a basis to improve upon. The formatters used in this commit are simple stubs that will be replaced by real formatters in later commits. The formatters that are slated to be replaced in this patch series don't have an availability macro to avoid merge conflicts. Note the formatter for `bool` uses `0` and `1` instead of "false" and "true". This will be fixed when the stub is replaced with a real formatter. Implements parts of: - P0645 Text Formatting Completes: - LWG3539 format_to must not copy models of output_iterator<const charT&> Reviewed By: ldionne, #libc, vitaut Differential Revision: https://reviews.llvm.org/D96664
2020-12-19 20:52:07 +08:00
#include <__variant/monostate.h>
[libc++][format] Add __format_arg_store. This implements the struct `__format_arg_store` and its dependencies: * the class basic_format_arg, * the class basic_format_args, * the class basic_format_context, * the function make_format_args, * the function wmake_format_args, * the function visit_format_arg, * several Standard required typedefs. The following parts will be implemented in a later patch: * the child class `basic_format_arg::handle`, * the function `basic_format_arg::basic_format_arg(const T* p)`. The following extension has been implemented: * the class basic_format_arg supports `__[u]int128_t` on platform where libc++ supports 128 bit integrals. Implements parts of: * P0645 Text Formatting Completes: * LWG3371 visit_format_arg and make_format_args are not hidden friends * LWG3542 basic_format_arg mishandles basic_string_view with custom traits Note https://mordante.github.io/blog/2021/06/05/format.html gives a bit more information about the goals and non-goals of this initial patch series. Reviewed By: #libc, ldionne, vitaut Differential Revision: https://reviews.llvm.org/D103357
2020-12-05 18:45:21 +08:00
#include <array>
[libc++][format] Implement formatters. This implements the initial version of the `std::formatter` class and its specializations. It also implements the following formatting functions: - `format` - `vformat` - `format_to` - `vformat_to` - `format_to_n` - `formatted_size` All functions have a `char` and `wchar_t` version. Parsing the format-spec and using the parsed format-spec hasn't been implemented. The code isn't optimized, neither for speed, nor for size. The goal is to have the rudimentary basics working, which can be used as a basis to improve upon. The formatters used in this commit are simple stubs that will be replaced by real formatters in later commits. The formatters that are slated to be replaced in this patch series don't have an availability macro to avoid merge conflicts. Note the formatter for `bool` uses `0` and `1` instead of "false" and "true". This will be fixed when the stub is replaced with a real formatter. Implements parts of: - P0645 Text Formatting Completes: - LWG3539 format_to must not copy models of output_iterator<const charT&> Reviewed By: ldionne, #libc, vitaut Differential Revision: https://reviews.llvm.org/D96664
2020-12-19 20:52:07 +08:00
#include <concepts>
#include <string>
#include <string_view>
#include <type_traits>
#ifndef _LIBCPP_HAS_NO_LOCALIZATION
#include <locale>
#endif
[libc++] Disable incomplete library features. Adds a new CMake option to disable the usage of incomplete headers. These incomplete headers are not guaranteed to be ABI stable. This option is intended to be used by vendors so they can avoid their users from code that's not ready for production usage. The option is enabled by default. Differential Revision: https://reviews.llvm.org/D106763
2021-07-25 15:18:53 +08:00
[libc++] Implement format_error. This is the first step at implementing <format>. It adds the <format> header and implements the `format_error`. class. Implemnts parts of: -P0645 Text Formatting Reviewed By: ldionne, #libc, miscco, curdeius Differential Revision: https://reviews.llvm.org/D92214
2020-11-27 02:12:18 +08:00
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
[libc++] Normalize all our '#pragma GCC system_header', and regression-test. Now we'll notice if a header forgets to include this magic phrase. Differential Revision: https://reviews.llvm.org/D118800
2022-02-02 09:16:40 +08:00
# pragma GCC system_header
[libc++] Implement format_error. This is the first step at implementing <format>. It adds the <format> header and implements the `format_error`. class. Implemnts parts of: -P0645 Text Formatting Reviewed By: ldionne, #libc, miscco, curdeius Differential Revision: https://reviews.llvm.org/D92214
2020-11-27 02:12:18 +08:00
#endif
[libc++][format] Add __format_arg_store. This implements the struct `__format_arg_store` and its dependencies: * the class basic_format_arg, * the class basic_format_args, * the class basic_format_context, * the function make_format_args, * the function wmake_format_args, * the function visit_format_arg, * several Standard required typedefs. The following parts will be implemented in a later patch: * the child class `basic_format_arg::handle`, * the function `basic_format_arg::basic_format_arg(const T* p)`. The following extension has been implemented: * the class basic_format_arg supports `__[u]int128_t` on platform where libc++ supports 128 bit integrals. Implements parts of: * P0645 Text Formatting Completes: * LWG3371 visit_format_arg and make_format_args are not hidden friends * LWG3542 basic_format_arg mishandles basic_string_view with custom traits Note https://mordante.github.io/blog/2021/06/05/format.html gives a bit more information about the goals and non-goals of this initial patch series. Reviewed By: #libc, ldionne, vitaut Differential Revision: https://reviews.llvm.org/D103357
2020-12-05 18:45:21 +08:00
_LIBCPP_BEGIN_NAMESPACE_STD
#if _LIBCPP_STD_VER > 17
[libc++][doc] Add a todo. As suggested in D113831.
2021-11-16 22:55:17 +08:00
// TODO FMT Move the implementation in this file to its own granular headers.
[libc++][format] Add __format_arg_store. This implements the struct `__format_arg_store` and its dependencies: * the class basic_format_arg, * the class basic_format_args, * the class basic_format_context, * the function make_format_args, * the function wmake_format_args, * the function visit_format_arg, * several Standard required typedefs. The following parts will be implemented in a later patch: * the child class `basic_format_arg::handle`, * the function `basic_format_arg::basic_format_arg(const T* p)`. The following extension has been implemented: * the class basic_format_arg supports `__[u]int128_t` on platform where libc++ supports 128 bit integrals. Implements parts of: * P0645 Text Formatting Completes: * LWG3371 visit_format_arg and make_format_args are not hidden friends * LWG3542 basic_format_arg mishandles basic_string_view with custom traits Note https://mordante.github.io/blog/2021/06/05/format.html gives a bit more information about the goals and non-goals of this initial patch series. Reviewed By: #libc, ldionne, vitaut Differential Revision: https://reviews.llvm.org/D103357
2020-12-05 18:45:21 +08:00
// TODO FMT Evaluate which templates should be external templates. This
// improves the efficiency of the header. However since the header is still
// under heavy development and not all classes are stable it makes no sense
// to do this optimization now.
using format_args = basic_format_args<format_context>;
[libc++] Add an option to disable wide character support in libc++ 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. Differential Revision: https://reviews.llvm.org/D111265
2021-08-24 03:32:36 +08:00
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
[libc++][format] Add __format_arg_store. This implements the struct `__format_arg_store` and its dependencies: * the class basic_format_arg, * the class basic_format_args, * the class basic_format_context, * the function make_format_args, * the function wmake_format_args, * the function visit_format_arg, * several Standard required typedefs. The following parts will be implemented in a later patch: * the child class `basic_format_arg::handle`, * the function `basic_format_arg::basic_format_arg(const T* p)`. The following extension has been implemented: * the class basic_format_arg supports `__[u]int128_t` on platform where libc++ supports 128 bit integrals. Implements parts of: * P0645 Text Formatting Completes: * LWG3371 visit_format_arg and make_format_args are not hidden friends * LWG3542 basic_format_arg mishandles basic_string_view with custom traits Note https://mordante.github.io/blog/2021/06/05/format.html gives a bit more information about the goals and non-goals of this initial patch series. Reviewed By: #libc, ldionne, vitaut Differential Revision: https://reviews.llvm.org/D103357
2020-12-05 18:45:21 +08:00
using wformat_args = basic_format_args<wformat_context>;
[libc++] Add an option to disable wide character support in libc++ 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. Differential Revision: https://reviews.llvm.org/D111265
2021-08-24 03:32:36 +08:00
#endif
[libc++][format] Add __format_arg_store. This implements the struct `__format_arg_store` and its dependencies: * the class basic_format_arg, * the class basic_format_args, * the class basic_format_context, * the function make_format_args, * the function wmake_format_args, * the function visit_format_arg, * several Standard required typedefs. The following parts will be implemented in a later patch: * the child class `basic_format_arg::handle`, * the function `basic_format_arg::basic_format_arg(const T* p)`. The following extension has been implemented: * the class basic_format_arg supports `__[u]int128_t` on platform where libc++ supports 128 bit integrals. Implements parts of: * P0645 Text Formatting Completes: * LWG3371 visit_format_arg and make_format_args are not hidden friends * LWG3542 basic_format_arg mishandles basic_string_view with custom traits Note https://mordante.github.io/blog/2021/06/05/format.html gives a bit more information about the goals and non-goals of this initial patch series. Reviewed By: #libc, ldionne, vitaut Differential Revision: https://reviews.llvm.org/D103357
2020-12-05 18:45:21 +08:00
template <class _Context = format_context, class... _Args>
[libc++][format] Use forwarding references. This implements a not accepted LWG issue. Not doing so would require integral types to use the handle class instead of being directly stored in the basic_format_arg. The previous code used `std::forward` in places where it wasn't required by the Standard. These are now removed. Implements: - P2418R2 Add support for std::generator-like types to std::format - LWG 3631 basic_format_arg(T&&) should use remove_cvref_t<T> throughout Reviewed By: ldionne, #libc Differential Revision: https://reviews.llvm.org/D127570
2021-10-06 01:25:37 +08:00
_LIBCPP_HIDE_FROM_ABI __format_arg_store<_Context, _Args...> make_format_args(_Args&&... __args) {
return _VSTD::__format_arg_store<_Context, _Args...>(__args...);
[libc++][format] Add __format_arg_store. This implements the struct `__format_arg_store` and its dependencies: * the class basic_format_arg, * the class basic_format_args, * the class basic_format_context, * the function make_format_args, * the function wmake_format_args, * the function visit_format_arg, * several Standard required typedefs. The following parts will be implemented in a later patch: * the child class `basic_format_arg::handle`, * the function `basic_format_arg::basic_format_arg(const T* p)`. The following extension has been implemented: * the class basic_format_arg supports `__[u]int128_t` on platform where libc++ supports 128 bit integrals. Implements parts of: * P0645 Text Formatting Completes: * LWG3371 visit_format_arg and make_format_args are not hidden friends * LWG3542 basic_format_arg mishandles basic_string_view with custom traits Note https://mordante.github.io/blog/2021/06/05/format.html gives a bit more information about the goals and non-goals of this initial patch series. Reviewed By: #libc, ldionne, vitaut Differential Revision: https://reviews.llvm.org/D103357
2020-12-05 18:45:21 +08:00
}
[libc++] Add an option to disable wide character support in libc++ 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. Differential Revision: https://reviews.llvm.org/D111265
2021-08-24 03:32:36 +08:00
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
[libc++][format] Add __format_arg_store. This implements the struct `__format_arg_store` and its dependencies: * the class basic_format_arg, * the class basic_format_args, * the class basic_format_context, * the function make_format_args, * the function wmake_format_args, * the function visit_format_arg, * several Standard required typedefs. The following parts will be implemented in a later patch: * the child class `basic_format_arg::handle`, * the function `basic_format_arg::basic_format_arg(const T* p)`. The following extension has been implemented: * the class basic_format_arg supports `__[u]int128_t` on platform where libc++ supports 128 bit integrals. Implements parts of: * P0645 Text Formatting Completes: * LWG3371 visit_format_arg and make_format_args are not hidden friends * LWG3542 basic_format_arg mishandles basic_string_view with custom traits Note https://mordante.github.io/blog/2021/06/05/format.html gives a bit more information about the goals and non-goals of this initial patch series. Reviewed By: #libc, ldionne, vitaut Differential Revision: https://reviews.llvm.org/D103357
2020-12-05 18:45:21 +08:00
template <class... _Args>
[libc++][format] Use forwarding references. This implements a not accepted LWG issue. Not doing so would require integral types to use the handle class instead of being directly stored in the basic_format_arg. The previous code used `std::forward` in places where it wasn't required by the Standard. These are now removed. Implements: - P2418R2 Add support for std::generator-like types to std::format - LWG 3631 basic_format_arg(T&&) should use remove_cvref_t<T> throughout Reviewed By: ldionne, #libc Differential Revision: https://reviews.llvm.org/D127570
2021-10-06 01:25:37 +08:00
_LIBCPP_HIDE_FROM_ABI __format_arg_store<wformat_context, _Args...> make_wformat_args(_Args&&... __args) {
return _VSTD::__format_arg_store<wformat_context, _Args...>(__args...);
[libc++][format] Add __format_arg_store. This implements the struct `__format_arg_store` and its dependencies: * the class basic_format_arg, * the class basic_format_args, * the class basic_format_context, * the function make_format_args, * the function wmake_format_args, * the function visit_format_arg, * several Standard required typedefs. The following parts will be implemented in a later patch: * the child class `basic_format_arg::handle`, * the function `basic_format_arg::basic_format_arg(const T* p)`. The following extension has been implemented: * the class basic_format_arg supports `__[u]int128_t` on platform where libc++ supports 128 bit integrals. Implements parts of: * P0645 Text Formatting Completes: * LWG3371 visit_format_arg and make_format_args are not hidden friends * LWG3542 basic_format_arg mishandles basic_string_view with custom traits Note https://mordante.github.io/blog/2021/06/05/format.html gives a bit more information about the goals and non-goals of this initial patch series. Reviewed By: #libc, ldionne, vitaut Differential Revision: https://reviews.llvm.org/D103357
2020-12-05 18:45:21 +08:00
}
[libc++] Add an option to disable wide character support in libc++ 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. Differential Revision: https://reviews.llvm.org/D111265
2021-08-24 03:32:36 +08:00
#endif
[libc++][format] Implement formatters. This implements the initial version of the `std::formatter` class and its specializations. It also implements the following formatting functions: - `format` - `vformat` - `format_to` - `vformat_to` - `format_to_n` - `formatted_size` All functions have a `char` and `wchar_t` version. Parsing the format-spec and using the parsed format-spec hasn't been implemented. The code isn't optimized, neither for speed, nor for size. The goal is to have the rudimentary basics working, which can be used as a basis to improve upon. The formatters used in this commit are simple stubs that will be replaced by real formatters in later commits. The formatters that are slated to be replaced in this patch series don't have an availability macro to avoid merge conflicts. Note the formatter for `bool` uses `0` and `1` instead of "false" and "true". This will be fixed when the stub is replaced with a real formatter. Implements parts of: - P0645 Text Formatting Completes: - LWG3539 format_to must not copy models of output_iterator<const charT&> Reviewed By: ldionne, #libc, vitaut Differential Revision: https://reviews.llvm.org/D96664
2020-12-19 20:52:07 +08:00
namespace __format {
[libc++][format] Implement format-string. Implements the compile-time checking of the formatting arguments. Completes: - P2216 std::format improvements Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D121530
2021-10-02 18:38:46 +08:00
/// Helper class parse and handle argument.
///
/// When parsing a handle which is not enabled the code is ill-formed.
/// This helper uses the parser of the appropriate formatter for the stored type.
template <class _CharT>
class _LIBCPP_TEMPLATE_VIS __compile_time_handle {
public:
_LIBCPP_HIDE_FROM_ABI
constexpr void __parse(basic_format_parse_context<_CharT>& __parse_ctx) const { __parse_(__parse_ctx); }
template <class _Tp>
_LIBCPP_HIDE_FROM_ABI constexpr void __enable() {
__parse_ = [](basic_format_parse_context<_CharT>& __parse_ctx) {
formatter<_Tp, _CharT> __f;
__parse_ctx.advance_to(__f.parse(__parse_ctx));
};
}
// Before calling __parse the proper handler needs to be set with __enable.
// The default handler isn't a core constant expression.
_LIBCPP_HIDE_FROM_ABI constexpr __compile_time_handle()
: __parse_([](basic_format_parse_context<_CharT>&) { __throw_format_error("Not a handle"); }) {}
private:
void (*__parse_)(basic_format_parse_context<_CharT>&);
};
// Dummy format_context only providing the parts used during constant
// validation of the basic-format-string.
template <class _CharT>
struct _LIBCPP_TEMPLATE_VIS __compile_time_basic_format_context {
public:
using char_type = _CharT;
_LIBCPP_HIDE_FROM_ABI constexpr explicit __compile_time_basic_format_context(
const __arg_t* __args, const __compile_time_handle<_CharT>* __handles, size_t __size)
: __args_(__args), __handles_(__handles), __size_(__size) {}
// During the compile-time validation nothing needs to be written.
// Therefore all operations of this iterator are a NOP.
struct iterator {
_LIBCPP_HIDE_FROM_ABI constexpr iterator& operator=(_CharT) { return *this; }
_LIBCPP_HIDE_FROM_ABI constexpr iterator& operator*() { return *this; }
_LIBCPP_HIDE_FROM_ABI constexpr iterator operator++(int) { return *this; }
};
_LIBCPP_HIDE_FROM_ABI constexpr __arg_t arg(size_t __id) const {
if (__id >= __size_)
__throw_format_error("Argument index out of bounds");
return __args_[__id];
}
_LIBCPP_HIDE_FROM_ABI constexpr const __compile_time_handle<_CharT>& __handle(size_t __id) const {
if (__id >= __size_)
__throw_format_error("Argument index out of bounds");
return __handles_[__id];
}
_LIBCPP_HIDE_FROM_ABI constexpr iterator out() { return {}; }
_LIBCPP_HIDE_FROM_ABI constexpr void advance_to(iterator) {}
private:
const __arg_t* __args_;
const __compile_time_handle<_CharT>* __handles_;
size_t __size_;
};
_LIBCPP_HIDE_FROM_ABI
constexpr void __compile_time_validate_integral(__arg_t __type) {
switch (__type) {
case __arg_t::__int:
case __arg_t::__long_long:
case __arg_t::__i128:
case __arg_t::__unsigned:
case __arg_t::__unsigned_long_long:
case __arg_t::__u128:
return;
default:
__throw_format_error("Argument isn't an integral type");
}
}
// _HasPrecision does the formatter have a precision?
template <class _CharT, class _Tp, bool _HasPrecision = false>
_LIBCPP_HIDE_FROM_ABI constexpr void
__compile_time_validate_argument(basic_format_parse_context<_CharT>& __parse_ctx,
__compile_time_basic_format_context<_CharT>& __ctx) {
formatter<_Tp, _CharT> __formatter;
__parse_ctx.advance_to(__formatter.parse(__parse_ctx));
// [format.string.std]/7
// ... If the corresponding formatting argument is not of integral type, or
// its value is negative for precision or non-positive for width, an
// exception of type format_error is thrown.
//
// Validate whether the arguments are integrals.
[libc++][format] Improve string formatters This changes the implementation of the formatter. Instead of inheriting from a specialized parser all formatters will use the same generic parser. This reduces the binary size. The new parser contains some additional fields only used in the chrono formatting. Since this doesn't change the size of the parser the fields are in the generic parser. The parser is designed to fit in 128-bit, making it cheap to pass by value. The new format function is a const member function. This isn't required by the Standard yet, but it will be after LWG-3636 is accepted. Additionally P2286 adds a formattable concept which requires the member function to be const qualified in C++23. This paper is likely to be accepted in the 2022 July plenary. Depends on D121530 NOTE parts of the code now contains duplicates for the current and new parser. The intention is to remove the duplication in followup patches. A general overview of the final code is available in D124620. That review however lacks a bit of polish. Most of the new code is based on the same algorithms used in the current code. The final version of this code reduces the binary size by 17 KB for this example code ``` int main() { { std::string_view sv{"hello world"}; std::format("{}{}|{}{}{}{}{}{}|{}{}{}{}{}{}|{}{}{}|{}{}|{}", true, '*', (signed char)(42), (short)(42), (int)(42), (long)(42), (long long)(42), (__int128_t)(42), (unsigned char)(42), (unsigned short)(42), (unsigned int)(42), (unsigned long)(42), (unsigned long long)(42), (__uint128_t)(42), (float)(42), (double)(42), (long double)(42), "hello world", sv, nullptr); } { std::wstring_view sv{L"hello world"}; std::format(L"{}{}|{}{}{}{}{}{}|{}{}{}{}{}{}|{}{}{}|{}{}|{}", true, L'*', (signed char)(42), (short)(42), (int)(42), (long)(42), (long long)(42), (__int128_t)(42), (unsigned char)(42), (unsigned short)(42), (unsigned int)(42), (unsigned long)(42), (unsigned long long)(42), (__uint128_t)(42), (float)(42), (double)(42), (long double)(42), L"hello world", sv, nullptr); } } ``` Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D125606
2021-12-29 01:48:04 +08:00
if constexpr (requires(formatter<_Tp, _CharT> __f) { __f.__width_needs_substitution(); }) {
// TODO FMT Remove this when parser v1 has been phased out.
if (__formatter.__width_needs_substitution())
__format::__compile_time_validate_integral(__ctx.arg(__formatter.__width));
if constexpr (_HasPrecision)
if (__formatter.__precision_needs_substitution())
__format::__compile_time_validate_integral(__ctx.arg(__formatter.__precision));
} else {
if (__formatter.__parser_.__width_as_arg_)
__format::__compile_time_validate_integral(__ctx.arg(__formatter.__parser_.__width_));
if constexpr (_HasPrecision)
if (__formatter.__parser_.__precision_as_arg_)
__format::__compile_time_validate_integral(__ctx.arg(__formatter.__parser_.__precision_));
}
[libc++][format] Implement format-string. Implements the compile-time checking of the formatting arguments. Completes: - P2216 std::format improvements Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D121530
2021-10-02 18:38:46 +08:00
}
template <class _CharT>
_LIBCPP_HIDE_FROM_ABI constexpr void __compile_time_visit_format_arg(basic_format_parse_context<_CharT>& __parse_ctx,
__compile_time_basic_format_context<_CharT>& __ctx,
__arg_t __type) {
switch (__type) {
case __arg_t::__none:
__throw_format_error("Invalid argument");
case __arg_t::__boolean:
return __format::__compile_time_validate_argument<_CharT, bool>(__parse_ctx, __ctx);
case __arg_t::__char_type:
return __format::__compile_time_validate_argument<_CharT, _CharT>(__parse_ctx, __ctx);
case __arg_t::__int:
return __format::__compile_time_validate_argument<_CharT, int>(__parse_ctx, __ctx);
case __arg_t::__long_long:
return __format::__compile_time_validate_argument<_CharT, long long>(__parse_ctx, __ctx);
case __arg_t::__i128:
# ifndef _LIBCPP_HAS_NO_INT128
return __format::__compile_time_validate_argument<_CharT, __int128_t>(__parse_ctx, __ctx);
# else
__throw_format_error("Invalid argument");
# endif
return;
case __arg_t::__unsigned:
return __format::__compile_time_validate_argument<_CharT, unsigned>(__parse_ctx, __ctx);
case __arg_t::__unsigned_long_long:
return __format::__compile_time_validate_argument<_CharT, unsigned long long>(__parse_ctx, __ctx);
case __arg_t::__u128:
# ifndef _LIBCPP_HAS_NO_INT128
return __format::__compile_time_validate_argument<_CharT, __uint128_t>(__parse_ctx, __ctx);
# else
__throw_format_error("Invalid argument");
# endif
return;
case __arg_t::__float:
return __format::__compile_time_validate_argument<_CharT, float, true>(__parse_ctx, __ctx);
case __arg_t::__double:
return __format::__compile_time_validate_argument<_CharT, double, true>(__parse_ctx, __ctx);
case __arg_t::__long_double:
return __format::__compile_time_validate_argument<_CharT, long double, true>(__parse_ctx, __ctx);
case __arg_t::__const_char_type_ptr:
return __format::__compile_time_validate_argument<_CharT, const _CharT*, true>(__parse_ctx, __ctx);
case __arg_t::__string_view:
return __format::__compile_time_validate_argument<_CharT, basic_string_view<_CharT>, true>(__parse_ctx, __ctx);
case __arg_t::__ptr:
return __format::__compile_time_validate_argument<_CharT, const void*>(__parse_ctx, __ctx);
case __arg_t::__handle:
__throw_format_error("Handle should use __compile_time_validate_handle_argument");
}
__throw_format_error("Invalid argument");
}
[libc++][format] Implement formatters. This implements the initial version of the `std::formatter` class and its specializations. It also implements the following formatting functions: - `format` - `vformat` - `format_to` - `vformat_to` - `format_to_n` - `formatted_size` All functions have a `char` and `wchar_t` version. Parsing the format-spec and using the parsed format-spec hasn't been implemented. The code isn't optimized, neither for speed, nor for size. The goal is to have the rudimentary basics working, which can be used as a basis to improve upon. The formatters used in this commit are simple stubs that will be replaced by real formatters in later commits. The formatters that are slated to be replaced in this patch series don't have an availability macro to avoid merge conflicts. Note the formatter for `bool` uses `0` and `1` instead of "false" and "true". This will be fixed when the stub is replaced with a real formatter. Implements parts of: - P0645 Text Formatting Completes: - LWG3539 format_to must not copy models of output_iterator<const charT&> Reviewed By: ldionne, #libc, vitaut Differential Revision: https://reviews.llvm.org/D96664
2020-12-19 20:52:07 +08:00
template <class _CharT, class _ParseCtx, class _Ctx>
[libc++][format] Implement format-string. Implements the compile-time checking of the formatting arguments. Completes: - P2216 std::format improvements Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D121530
2021-10-02 18:38:46 +08:00
_LIBCPP_HIDE_FROM_ABI constexpr const _CharT*
[libc++][format] Implement formatters. This implements the initial version of the `std::formatter` class and its specializations. It also implements the following formatting functions: - `format` - `vformat` - `format_to` - `vformat_to` - `format_to_n` - `formatted_size` All functions have a `char` and `wchar_t` version. Parsing the format-spec and using the parsed format-spec hasn't been implemented. The code isn't optimized, neither for speed, nor for size. The goal is to have the rudimentary basics working, which can be used as a basis to improve upon. The formatters used in this commit are simple stubs that will be replaced by real formatters in later commits. The formatters that are slated to be replaced in this patch series don't have an availability macro to avoid merge conflicts. Note the formatter for `bool` uses `0` and `1` instead of "false" and "true". This will be fixed when the stub is replaced with a real formatter. Implements parts of: - P0645 Text Formatting Completes: - LWG3539 format_to must not copy models of output_iterator<const charT&> Reviewed By: ldionne, #libc, vitaut Differential Revision: https://reviews.llvm.org/D96664
2020-12-19 20:52:07 +08:00
__handle_replacement_field(const _CharT* __begin, const _CharT* __end,
_ParseCtx& __parse_ctx, _Ctx& __ctx) {
__format::__parse_number_result __r =
__format::__parse_arg_id(__begin, __end, __parse_ctx);
[libc++][format] Improves parsing speed. A format string like "{}" is quite common. In this case avoid parsing the format-spec when it's not present. Before the parsing was always called, therefore some refactoring is done to make sure the formatters work properly when their parse member isn't called. From the wording it's not entirely clear whether this optimization is allowed [tab:formatter] ``` and the range [pc.begin(), pc.end()) from the last call to f.parse(pc). ``` Implies there's always a call to `f.parse` even when the format-spec isn't present. Therefore this optimization isn't done for handle classes; it's unclear whether that would break user defined formatters. The improvements give a small reduciton is code size: 719408 12472 488 732368 b2cd0 before 718824 12472 488 731784 b2a88 after The performance benefits when not using a format-spec are: ``` Comparing ./formatter_int.libcxx.out-baseline to ./formatter_int.libcxx.out Benchmark Time CPU Time Old Time New CPU Old CPU New ---------------------------------------------------------------------------------------------------------------------------------------------------- BM_Basic<uint32_t> -0.0688 -0.0687 67 62 67 62 BM_Basic<int32_t> -0.1105 -0.1107 73 65 73 65 BM_Basic<uint64_t> -0.1053 -0.1049 95 85 95 85 BM_Basic<int64_t> -0.0889 -0.0888 93 85 93 85 BM_BasicLow<__uint128_t> -0.0655 -0.0655 96 90 96 90 BM_BasicLow<__int128_t> -0.0693 -0.0694 97 90 97 90 BM_Basic<__uint128_t> -0.0359 -0.0359 256 247 256 247 BM_Basic<__int128_t> -0.0414 -0.0414 239 229 239 229 ``` For the cases where a format-spec is used the results remain similar, some are faster some are slower, differing per run. Reviewed By: ldionne, #libc Differential Revision: https://reviews.llvm.org/D129426
2022-07-09 22:14:40 +08:00
bool __parse = *__r.__ptr == _CharT(':');
[libc++][format] Implement formatters. This implements the initial version of the `std::formatter` class and its specializations. It also implements the following formatting functions: - `format` - `vformat` - `format_to` - `vformat_to` - `format_to_n` - `formatted_size` All functions have a `char` and `wchar_t` version. Parsing the format-spec and using the parsed format-spec hasn't been implemented. The code isn't optimized, neither for speed, nor for size. The goal is to have the rudimentary basics working, which can be used as a basis to improve upon. The formatters used in this commit are simple stubs that will be replaced by real formatters in later commits. The formatters that are slated to be replaced in this patch series don't have an availability macro to avoid merge conflicts. Note the formatter for `bool` uses `0` and `1` instead of "false" and "true". This will be fixed when the stub is replaced with a real formatter. Implements parts of: - P0645 Text Formatting Completes: - LWG3539 format_to must not copy models of output_iterator<const charT&> Reviewed By: ldionne, #libc, vitaut Differential Revision: https://reviews.llvm.org/D96664
2020-12-19 20:52:07 +08:00
switch (*__r.__ptr) {
case _CharT(':'):
// The arg-id has a format-specifier, advance the input to the format-spec.
__parse_ctx.advance_to(__r.__ptr + 1);
break;
case _CharT('}'):
// The arg-id has no format-specifier.
__parse_ctx.advance_to(__r.__ptr);
break;
default:
__throw_format_error(
"The replacement field arg-id should terminate at a ':' or '}'");
}
[libc++][format] Implement format-string. Implements the compile-time checking of the formatting arguments. Completes: - P2216 std::format improvements Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D121530
2021-10-02 18:38:46 +08:00
if constexpr (same_as<_Ctx, __compile_time_basic_format_context<_CharT>>) {
__arg_t __type = __ctx.arg(__r.__value);
if (__type == __arg_t::__handle)
__ctx.__handle(__r.__value).__parse(__parse_ctx);
else
[libc++][format] Improves parsing speed. A format string like "{}" is quite common. In this case avoid parsing the format-spec when it's not present. Before the parsing was always called, therefore some refactoring is done to make sure the formatters work properly when their parse member isn't called. From the wording it's not entirely clear whether this optimization is allowed [tab:formatter] ``` and the range [pc.begin(), pc.end()) from the last call to f.parse(pc). ``` Implies there's always a call to `f.parse` even when the format-spec isn't present. Therefore this optimization isn't done for handle classes; it's unclear whether that would break user defined formatters. The improvements give a small reduciton is code size: 719408 12472 488 732368 b2cd0 before 718824 12472 488 731784 b2a88 after The performance benefits when not using a format-spec are: ``` Comparing ./formatter_int.libcxx.out-baseline to ./formatter_int.libcxx.out Benchmark Time CPU Time Old Time New CPU Old CPU New ---------------------------------------------------------------------------------------------------------------------------------------------------- BM_Basic<uint32_t> -0.0688 -0.0687 67 62 67 62 BM_Basic<int32_t> -0.1105 -0.1107 73 65 73 65 BM_Basic<uint64_t> -0.1053 -0.1049 95 85 95 85 BM_Basic<int64_t> -0.0889 -0.0888 93 85 93 85 BM_BasicLow<__uint128_t> -0.0655 -0.0655 96 90 96 90 BM_BasicLow<__int128_t> -0.0693 -0.0694 97 90 97 90 BM_Basic<__uint128_t> -0.0359 -0.0359 256 247 256 247 BM_Basic<__int128_t> -0.0414 -0.0414 239 229 239 229 ``` For the cases where a format-spec is used the results remain similar, some are faster some are slower, differing per run. Reviewed By: ldionne, #libc Differential Revision: https://reviews.llvm.org/D129426
2022-07-09 22:14:40 +08:00
__format::__compile_time_visit_format_arg(__parse_ctx, __ctx, __type);
[libc++][format] Implement format-string. Implements the compile-time checking of the formatting arguments. Completes: - P2216 std::format improvements Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D121530
2021-10-02 18:38:46 +08:00
} else
_VSTD::visit_format_arg(
[&](auto __arg) {
if constexpr (same_as<decltype(__arg), monostate>)
__throw_format_error("Argument index out of bounds");
else if constexpr (same_as<decltype(__arg), typename basic_format_arg<_Ctx>::handle>)
__arg.format(__parse_ctx, __ctx);
else {
formatter<decltype(__arg), _CharT> __formatter;
[libc++][format] Improves parsing speed. A format string like "{}" is quite common. In this case avoid parsing the format-spec when it's not present. Before the parsing was always called, therefore some refactoring is done to make sure the formatters work properly when their parse member isn't called. From the wording it's not entirely clear whether this optimization is allowed [tab:formatter] ``` and the range [pc.begin(), pc.end()) from the last call to f.parse(pc). ``` Implies there's always a call to `f.parse` even when the format-spec isn't present. Therefore this optimization isn't done for handle classes; it's unclear whether that would break user defined formatters. The improvements give a small reduciton is code size: 719408 12472 488 732368 b2cd0 before 718824 12472 488 731784 b2a88 after The performance benefits when not using a format-spec are: ``` Comparing ./formatter_int.libcxx.out-baseline to ./formatter_int.libcxx.out Benchmark Time CPU Time Old Time New CPU Old CPU New ---------------------------------------------------------------------------------------------------------------------------------------------------- BM_Basic<uint32_t> -0.0688 -0.0687 67 62 67 62 BM_Basic<int32_t> -0.1105 -0.1107 73 65 73 65 BM_Basic<uint64_t> -0.1053 -0.1049 95 85 95 85 BM_Basic<int64_t> -0.0889 -0.0888 93 85 93 85 BM_BasicLow<__uint128_t> -0.0655 -0.0655 96 90 96 90 BM_BasicLow<__int128_t> -0.0693 -0.0694 97 90 97 90 BM_Basic<__uint128_t> -0.0359 -0.0359 256 247 256 247 BM_Basic<__int128_t> -0.0414 -0.0414 239 229 239 229 ``` For the cases where a format-spec is used the results remain similar, some are faster some are slower, differing per run. Reviewed By: ldionne, #libc Differential Revision: https://reviews.llvm.org/D129426
2022-07-09 22:14:40 +08:00
if (__parse)
__parse_ctx.advance_to(__formatter.parse(__parse_ctx));
[libc++][format] Implement format-string. Implements the compile-time checking of the formatting arguments. Completes: - P2216 std::format improvements Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D121530
2021-10-02 18:38:46 +08:00
__ctx.advance_to(__formatter.format(__arg, __ctx));
}
},
__ctx.arg(__r.__value));
[libc++][format] Implement formatters. This implements the initial version of the `std::formatter` class and its specializations. It also implements the following formatting functions: - `format` - `vformat` - `format_to` - `vformat_to` - `format_to_n` - `formatted_size` All functions have a `char` and `wchar_t` version. Parsing the format-spec and using the parsed format-spec hasn't been implemented. The code isn't optimized, neither for speed, nor for size. The goal is to have the rudimentary basics working, which can be used as a basis to improve upon. The formatters used in this commit are simple stubs that will be replaced by real formatters in later commits. The formatters that are slated to be replaced in this patch series don't have an availability macro to avoid merge conflicts. Note the formatter for `bool` uses `0` and `1` instead of "false" and "true". This will be fixed when the stub is replaced with a real formatter. Implements parts of: - P0645 Text Formatting Completes: - LWG3539 format_to must not copy models of output_iterator<const charT&> Reviewed By: ldionne, #libc, vitaut Differential Revision: https://reviews.llvm.org/D96664
2020-12-19 20:52:07 +08:00
__begin = __parse_ctx.begin();
if (__begin == __end || *__begin != _CharT('}'))
__throw_format_error("The replacement field misses a terminating '}'");
return ++__begin;
}
template <class _ParseCtx, class _Ctx>
[libc++][format] Implement format-string. Implements the compile-time checking of the formatting arguments. Completes: - P2216 std::format improvements Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D121530
2021-10-02 18:38:46 +08:00
_LIBCPP_HIDE_FROM_ABI constexpr typename _Ctx::iterator
[libc++][format] Implement formatters. This implements the initial version of the `std::formatter` class and its specializations. It also implements the following formatting functions: - `format` - `vformat` - `format_to` - `vformat_to` - `format_to_n` - `formatted_size` All functions have a `char` and `wchar_t` version. Parsing the format-spec and using the parsed format-spec hasn't been implemented. The code isn't optimized, neither for speed, nor for size. The goal is to have the rudimentary basics working, which can be used as a basis to improve upon. The formatters used in this commit are simple stubs that will be replaced by real formatters in later commits. The formatters that are slated to be replaced in this patch series don't have an availability macro to avoid merge conflicts. Note the formatter for `bool` uses `0` and `1` instead of "false" and "true". This will be fixed when the stub is replaced with a real formatter. Implements parts of: - P0645 Text Formatting Completes: - LWG3539 format_to must not copy models of output_iterator<const charT&> Reviewed By: ldionne, #libc, vitaut Differential Revision: https://reviews.llvm.org/D96664
2020-12-19 20:52:07 +08:00
__vformat_to(_ParseCtx&& __parse_ctx, _Ctx&& __ctx) {
using _CharT = typename _ParseCtx::char_type;
static_assert(same_as<typename _Ctx::char_type, _CharT>);
const _CharT* __begin = __parse_ctx.begin();
const _CharT* __end = __parse_ctx.end();
typename _Ctx::iterator __out_it = __ctx.out();
while (__begin != __end) {
switch (*__begin) {
case _CharT('{'):
++__begin;
if (__begin == __end)
__throw_format_error("The format string terminates at a '{'");
if (*__begin != _CharT('{')) [[likely]] {
__ctx.advance_to(_VSTD::move(__out_it));
__begin =
__handle_replacement_field(__begin, __end, __parse_ctx, __ctx);
__out_it = __ctx.out();
// The output is written and __begin points to the next character. So
// start the next iteration.
continue;
}
// The string is an escape character.
break;
case _CharT('}'):
++__begin;
if (__begin == __end || *__begin != _CharT('}'))
__throw_format_error(
"The format string contains an invalid escape sequence");
break;
}
// Copy the character to the output verbatim.
*__out_it++ = *__begin++;
}
return __out_it;
}
} // namespace __format
[libc++][format] Implement format-string. Implements the compile-time checking of the formatting arguments. Completes: - P2216 std::format improvements Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D121530
2021-10-02 18:38:46 +08:00
template <class _CharT, class... _Args>
struct _LIBCPP_TEMPLATE_VIS __basic_format_string {
basic_string_view<_CharT> __str_;
template <class _Tp>
requires convertible_to<const _Tp&, basic_string_view<_CharT>>
consteval __basic_format_string(const _Tp& __str) : __str_{__str} {
__format::__vformat_to(basic_format_parse_context<_CharT>{__str_, sizeof...(_Args)},
_Context{__types_.data(), __handles_.data(), sizeof...(_Args)});
}
private:
using _Context = __format::__compile_time_basic_format_context<_CharT>;
static constexpr array<__format::__arg_t, sizeof...(_Args)> __types_{
__format::__determine_arg_t<_Context, remove_cvref_t<_Args>>()...};
// TODO FMT remove this work-around when the AIX ICE has been resolved.
# if defined(_AIX) && defined(_LIBCPP_CLANG_VER) && _LIBCPP_CLANG_VER < 1400
template <class _Tp>
static constexpr __format::__compile_time_handle<_CharT> __get_handle() {
__format::__compile_time_handle<_CharT> __handle;
if (__format::__determine_arg_t<_Context, _Tp>() == __format::__arg_t::__handle)
__handle.template __enable<_Tp>();
return __handle;
}
static constexpr array<__format::__compile_time_handle<_CharT>, sizeof...(_Args)> __handles_{
__get_handle<_Args>()...};
# else
static constexpr array<__format::__compile_time_handle<_CharT>, sizeof...(_Args)> __handles_{[] {
using _Tp = remove_cvref_t<_Args>;
__format::__compile_time_handle<_CharT> __handle;
if (__format::__determine_arg_t<_Context, _Tp>() == __format::__arg_t::__handle)
__handle.template __enable<_Tp>();
return __handle;
}()...};
# endif
};
template <class... _Args>
using __format_string_t = __basic_format_string<char, type_identity_t<_Args>...>;
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
template <class... _Args>
using __wformat_string_t = __basic_format_string<wchar_t, type_identity_t<_Args>...>;
#endif
[libc++][format][1/6] Reduce binary size. This removes the `format_args_t` from `<format>` and adjusts the type of the `format_args` for the `vformat_to` overloads. The `format_context` uses a `back_insert_iterator<string>` therefore the new `output_iterator` function uses a `string` as its temporary storage buffer. This isn't ideal. The next patches in this series will improve this. These improvements make it easy to also improve `format_to_n` and `formatted_size`. This addresses P2216 `6. Binary size`. P2216 `5. Compile-time checks` are not part of this change. Implements parts of: - P2216 std::format improvements Depends on D103670 Reviewed By: ldionne, #libc Differential Revision: https://reviews.llvm.org/D110494
2021-09-04 19:26:58 +08:00
template <class _OutIt, class _CharT, class _FormatOutIt>
[libc++][format] Implement formatters. This implements the initial version of the `std::formatter` class and its specializations. It also implements the following formatting functions: - `format` - `vformat` - `format_to` - `vformat_to` - `format_to_n` - `formatted_size` All functions have a `char` and `wchar_t` version. Parsing the format-spec and using the parsed format-spec hasn't been implemented. The code isn't optimized, neither for speed, nor for size. The goal is to have the rudimentary basics working, which can be used as a basis to improve upon. The formatters used in this commit are simple stubs that will be replaced by real formatters in later commits. The formatters that are slated to be replaced in this patch series don't have an availability macro to avoid merge conflicts. Note the formatter for `bool` uses `0` and `1` instead of "false" and "true". This will be fixed when the stub is replaced with a real formatter. Implements parts of: - P0645 Text Formatting Completes: - LWG3539 format_to must not copy models of output_iterator<const charT&> Reviewed By: ldionne, #libc, vitaut Differential Revision: https://reviews.llvm.org/D96664
2020-12-19 20:52:07 +08:00
requires(output_iterator<_OutIt, const _CharT&>) _LIBCPP_HIDE_FROM_ABI _OutIt
[libc++][format][1/6] Reduce binary size. This removes the `format_args_t` from `<format>` and adjusts the type of the `format_args` for the `vformat_to` overloads. The `format_context` uses a `back_insert_iterator<string>` therefore the new `output_iterator` function uses a `string` as its temporary storage buffer. This isn't ideal. The next patches in this series will improve this. These improvements make it easy to also improve `format_to_n` and `formatted_size`. This addresses P2216 `6. Binary size`. P2216 `5. Compile-time checks` are not part of this change. Implements parts of: - P2216 std::format improvements Depends on D103670 Reviewed By: ldionne, #libc Differential Revision: https://reviews.llvm.org/D110494
2021-09-04 19:26:58 +08:00
__vformat_to(
_OutIt __out_it, basic_string_view<_CharT> __fmt,
basic_format_args<basic_format_context<_FormatOutIt, _CharT>> __args) {
if constexpr (same_as<_OutIt, _FormatOutIt>)
return _VSTD::__format::__vformat_to(
basic_format_parse_context{__fmt, __args.__size()},
_VSTD::__format_context_create(_VSTD::move(__out_it), __args));
else {
[libc++][format][2/6] Adds a __output_iterator. Instead of using a temporary `string` in `__vformat_to_wrapped` use a new generic iterator. This aids to reduce the number of template instantions and avoids using a `string` to buffer the entire formatted output. This changes the type of `format_context` and `wformat_context`, this can still be done since the code isn't ABI stable yet. Several approaches have been evaluated: - Using a __output_buffer base class with: - a put function to store the buffer in its internal buffer - a virtual flush function to copy the internal buffer to the output - Using a `function` to forward the output operation to the output buffer, much like the next method. - Using a type erased function point to store the data in the buffer. The last version resulted in the best performance. For some cases there's still a loss of speed over the original method. This loss many becomes apparent when large strings are copied to a pointer like iterator, before the compiler optimized this using `memcpy`. Reviewed By: ldionne, vitaut, #libc Differential Revision: https://reviews.llvm.org/D110495
2021-09-05 03:05:23 +08:00
__format::__format_buffer<_OutIt, _CharT> __buffer{_VSTD::move(__out_it)};
[libc++][format][1/6] Reduce binary size. This removes the `format_args_t` from `<format>` and adjusts the type of the `format_args` for the `vformat_to` overloads. The `format_context` uses a `back_insert_iterator<string>` therefore the new `output_iterator` function uses a `string` as its temporary storage buffer. This isn't ideal. The next patches in this series will improve this. These improvements make it easy to also improve `format_to_n` and `formatted_size`. This addresses P2216 `6. Binary size`. P2216 `5. Compile-time checks` are not part of this change. Implements parts of: - P2216 std::format improvements Depends on D103670 Reviewed By: ldionne, #libc Differential Revision: https://reviews.llvm.org/D110494
2021-09-04 19:26:58 +08:00
_VSTD::__format::__vformat_to(
basic_format_parse_context{__fmt, __args.__size()},
[libc++][format][2/6] Adds a __output_iterator. Instead of using a temporary `string` in `__vformat_to_wrapped` use a new generic iterator. This aids to reduce the number of template instantions and avoids using a `string` to buffer the entire formatted output. This changes the type of `format_context` and `wformat_context`, this can still be done since the code isn't ABI stable yet. Several approaches have been evaluated: - Using a __output_buffer base class with: - a put function to store the buffer in its internal buffer - a virtual flush function to copy the internal buffer to the output - Using a `function` to forward the output operation to the output buffer, much like the next method. - Using a type erased function point to store the data in the buffer. The last version resulted in the best performance. For some cases there's still a loss of speed over the original method. This loss many becomes apparent when large strings are copied to a pointer like iterator, before the compiler optimized this using `memcpy`. Reviewed By: ldionne, vitaut, #libc Differential Revision: https://reviews.llvm.org/D110495
2021-09-05 03:05:23 +08:00
_VSTD::__format_context_create(__buffer.make_output_iterator(),
__args));
return _VSTD::move(__buffer).out();
[libc++][format][1/6] Reduce binary size. This removes the `format_args_t` from `<format>` and adjusts the type of the `format_args` for the `vformat_to` overloads. The `format_context` uses a `back_insert_iterator<string>` therefore the new `output_iterator` function uses a `string` as its temporary storage buffer. This isn't ideal. The next patches in this series will improve this. These improvements make it easy to also improve `format_to_n` and `formatted_size`. This addresses P2216 `6. Binary size`. P2216 `5. Compile-time checks` are not part of this change. Implements parts of: - P2216 std::format improvements Depends on D103670 Reviewed By: ldionne, #libc Differential Revision: https://reviews.llvm.org/D110494
2021-09-04 19:26:58 +08:00
}
[libc++][format] Implement formatters. This implements the initial version of the `std::formatter` class and its specializations. It also implements the following formatting functions: - `format` - `vformat` - `format_to` - `vformat_to` - `format_to_n` - `formatted_size` All functions have a `char` and `wchar_t` version. Parsing the format-spec and using the parsed format-spec hasn't been implemented. The code isn't optimized, neither for speed, nor for size. The goal is to have the rudimentary basics working, which can be used as a basis to improve upon. The formatters used in this commit are simple stubs that will be replaced by real formatters in later commits. The formatters that are slated to be replaced in this patch series don't have an availability macro to avoid merge conflicts. Note the formatter for `bool` uses `0` and `1` instead of "false" and "true". This will be fixed when the stub is replaced with a real formatter. Implements parts of: - P0645 Text Formatting Completes: - LWG3539 format_to must not copy models of output_iterator<const charT&> Reviewed By: ldionne, #libc, vitaut Differential Revision: https://reviews.llvm.org/D96664
2020-12-19 20:52:07 +08:00
}
[libc++][format][5/6] Improve format_to_n. Use a specialized buffer wrapper to limit the number of insertions in the buffer. After the limit has been reached the buffer only needs to count the number of insertions to return the buffer size required to store the entire output. Depends on D110498 Reviewed By: #libc, Mordante Differential Revision: https://reviews.llvm.org/D110499
2021-09-26 23:04:53 +08:00
// The function is _LIBCPP_ALWAYS_INLINE since the compiler is bad at inlining
// https://reviews.llvm.org/D110499#inline-1180704
// TODO FMT Evaluate whether we want to file a Clang bug report regarding this.
[libc++][format] Implement formatters. This implements the initial version of the `std::formatter` class and its specializations. It also implements the following formatting functions: - `format` - `vformat` - `format_to` - `vformat_to` - `format_to_n` - `formatted_size` All functions have a `char` and `wchar_t` version. Parsing the format-spec and using the parsed format-spec hasn't been implemented. The code isn't optimized, neither for speed, nor for size. The goal is to have the rudimentary basics working, which can be used as a basis to improve upon. The formatters used in this commit are simple stubs that will be replaced by real formatters in later commits. The formatters that are slated to be replaced in this patch series don't have an availability macro to avoid merge conflicts. Note the formatter for `bool` uses `0` and `1` instead of "false" and "true". This will be fixed when the stub is replaced with a real formatter. Implements parts of: - P0645 Text Formatting Completes: - LWG3539 format_to must not copy models of output_iterator<const charT&> Reviewed By: ldionne, #libc, vitaut Differential Revision: https://reviews.llvm.org/D96664
2020-12-19 20:52:07 +08:00
template <output_iterator<const char&> _OutIt>
[libc++][format][1/6] Reduce binary size. This removes the `format_args_t` from `<format>` and adjusts the type of the `format_args` for the `vformat_to` overloads. The `format_context` uses a `back_insert_iterator<string>` therefore the new `output_iterator` function uses a `string` as its temporary storage buffer. This isn't ideal. The next patches in this series will improve this. These improvements make it easy to also improve `format_to_n` and `formatted_size`. This addresses P2216 `6. Binary size`. P2216 `5. Compile-time checks` are not part of this change. Implements parts of: - P2216 std::format improvements Depends on D103670 Reviewed By: ldionne, #libc Differential Revision: https://reviews.llvm.org/D110494
2021-09-04 19:26:58 +08:00
_LIBCPP_ALWAYS_INLINE _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT _OutIt
vformat_to(_OutIt __out_it, string_view __fmt, format_args __args) {
[libc++][format] Implement formatters. This implements the initial version of the `std::formatter` class and its specializations. It also implements the following formatting functions: - `format` - `vformat` - `format_to` - `vformat_to` - `format_to_n` - `formatted_size` All functions have a `char` and `wchar_t` version. Parsing the format-spec and using the parsed format-spec hasn't been implemented. The code isn't optimized, neither for speed, nor for size. The goal is to have the rudimentary basics working, which can be used as a basis to improve upon. The formatters used in this commit are simple stubs that will be replaced by real formatters in later commits. The formatters that are slated to be replaced in this patch series don't have an availability macro to avoid merge conflicts. Note the formatter for `bool` uses `0` and `1` instead of "false" and "true". This will be fixed when the stub is replaced with a real formatter. Implements parts of: - P0645 Text Formatting Completes: - LWG3539 format_to must not copy models of output_iterator<const charT&> Reviewed By: ldionne, #libc, vitaut Differential Revision: https://reviews.llvm.org/D96664
2020-12-19 20:52:07 +08:00
return _VSTD::__vformat_to(_VSTD::move(__out_it), __fmt, __args);
}
[libc++] Add an option to disable wide character support in libc++ 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. Differential Revision: https://reviews.llvm.org/D111265
2021-08-24 03:32:36 +08:00
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
[libc++][format] Implement formatters. This implements the initial version of the `std::formatter` class and its specializations. It also implements the following formatting functions: - `format` - `vformat` - `format_to` - `vformat_to` - `format_to_n` - `formatted_size` All functions have a `char` and `wchar_t` version. Parsing the format-spec and using the parsed format-spec hasn't been implemented. The code isn't optimized, neither for speed, nor for size. The goal is to have the rudimentary basics working, which can be used as a basis to improve upon. The formatters used in this commit are simple stubs that will be replaced by real formatters in later commits. The formatters that are slated to be replaced in this patch series don't have an availability macro to avoid merge conflicts. Note the formatter for `bool` uses `0` and `1` instead of "false" and "true". This will be fixed when the stub is replaced with a real formatter. Implements parts of: - P0645 Text Formatting Completes: - LWG3539 format_to must not copy models of output_iterator<const charT&> Reviewed By: ldionne, #libc, vitaut Differential Revision: https://reviews.llvm.org/D96664
2020-12-19 20:52:07 +08:00
template <output_iterator<const wchar_t&> _OutIt>
[libc++][format][1/6] Reduce binary size. This removes the `format_args_t` from `<format>` and adjusts the type of the `format_args` for the `vformat_to` overloads. The `format_context` uses a `back_insert_iterator<string>` therefore the new `output_iterator` function uses a `string` as its temporary storage buffer. This isn't ideal. The next patches in this series will improve this. These improvements make it easy to also improve `format_to_n` and `formatted_size`. This addresses P2216 `6. Binary size`. P2216 `5. Compile-time checks` are not part of this change. Implements parts of: - P2216 std::format improvements Depends on D103670 Reviewed By: ldionne, #libc Differential Revision: https://reviews.llvm.org/D110494
2021-09-04 19:26:58 +08:00
_LIBCPP_ALWAYS_INLINE _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT _OutIt
vformat_to(_OutIt __out_it, wstring_view __fmt, wformat_args __args) {
[libc++][format] Implement formatters. This implements the initial version of the `std::formatter` class and its specializations. It also implements the following formatting functions: - `format` - `vformat` - `format_to` - `vformat_to` - `format_to_n` - `formatted_size` All functions have a `char` and `wchar_t` version. Parsing the format-spec and using the parsed format-spec hasn't been implemented. The code isn't optimized, neither for speed, nor for size. The goal is to have the rudimentary basics working, which can be used as a basis to improve upon. The formatters used in this commit are simple stubs that will be replaced by real formatters in later commits. The formatters that are slated to be replaced in this patch series don't have an availability macro to avoid merge conflicts. Note the formatter for `bool` uses `0` and `1` instead of "false" and "true". This will be fixed when the stub is replaced with a real formatter. Implements parts of: - P0645 Text Formatting Completes: - LWG3539 format_to must not copy models of output_iterator<const charT&> Reviewed By: ldionne, #libc, vitaut Differential Revision: https://reviews.llvm.org/D96664
2020-12-19 20:52:07 +08:00
return _VSTD::__vformat_to(_VSTD::move(__out_it), __fmt, __args);
}
[libc++] Add an option to disable wide character support in libc++ 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. Differential Revision: https://reviews.llvm.org/D111265
2021-08-24 03:32:36 +08:00
#endif
[libc++][format] Implement formatters. This implements the initial version of the `std::formatter` class and its specializations. It also implements the following formatting functions: - `format` - `vformat` - `format_to` - `vformat_to` - `format_to_n` - `formatted_size` All functions have a `char` and `wchar_t` version. Parsing the format-spec and using the parsed format-spec hasn't been implemented. The code isn't optimized, neither for speed, nor for size. The goal is to have the rudimentary basics working, which can be used as a basis to improve upon. The formatters used in this commit are simple stubs that will be replaced by real formatters in later commits. The formatters that are slated to be replaced in this patch series don't have an availability macro to avoid merge conflicts. Note the formatter for `bool` uses `0` and `1` instead of "false" and "true". This will be fixed when the stub is replaced with a real formatter. Implements parts of: - P0645 Text Formatting Completes: - LWG3539 format_to must not copy models of output_iterator<const charT&> Reviewed By: ldionne, #libc, vitaut Differential Revision: https://reviews.llvm.org/D96664
2020-12-19 20:52:07 +08:00
template <output_iterator<const char&> _OutIt, class... _Args>
[libc++][format][1/6] Reduce binary size. This removes the `format_args_t` from `<format>` and adjusts the type of the `format_args` for the `vformat_to` overloads. The `format_context` uses a `back_insert_iterator<string>` therefore the new `output_iterator` function uses a `string` as its temporary storage buffer. This isn't ideal. The next patches in this series will improve this. These improvements make it easy to also improve `format_to_n` and `formatted_size`. This addresses P2216 `6. Binary size`. P2216 `5. Compile-time checks` are not part of this change. Implements parts of: - P2216 std::format improvements Depends on D103670 Reviewed By: ldionne, #libc Differential Revision: https://reviews.llvm.org/D110494
2021-09-04 19:26:58 +08:00
_LIBCPP_ALWAYS_INLINE _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT _OutIt
[libc++][format] Use forwarding references. This implements a not accepted LWG issue. Not doing so would require integral types to use the handle class instead of being directly stored in the basic_format_arg. The previous code used `std::forward` in places where it wasn't required by the Standard. These are now removed. Implements: - P2418R2 Add support for std::generator-like types to std::format - LWG 3631 basic_format_arg(T&&) should use remove_cvref_t<T> throughout Reviewed By: ldionne, #libc Differential Revision: https://reviews.llvm.org/D127570
2021-10-06 01:25:37 +08:00
format_to(_OutIt __out_it, __format_string_t<_Args...> __fmt, _Args&&... __args) {
[libc++][format] Implement format-string. Implements the compile-time checking of the formatting arguments. Completes: - P2216 std::format improvements Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D121530
2021-10-02 18:38:46 +08:00
return _VSTD::vformat_to(_VSTD::move(__out_it), __fmt.__str_,
[libc++][format][1/6] Reduce binary size. This removes the `format_args_t` from `<format>` and adjusts the type of the `format_args` for the `vformat_to` overloads. The `format_context` uses a `back_insert_iterator<string>` therefore the new `output_iterator` function uses a `string` as its temporary storage buffer. This isn't ideal. The next patches in this series will improve this. These improvements make it easy to also improve `format_to_n` and `formatted_size`. This addresses P2216 `6. Binary size`. P2216 `5. Compile-time checks` are not part of this change. Implements parts of: - P2216 std::format improvements Depends on D103670 Reviewed By: ldionne, #libc Differential Revision: https://reviews.llvm.org/D110494
2021-09-04 19:26:58 +08:00
_VSTD::make_format_args(__args...));
[libc++][format] Implement formatters. This implements the initial version of the `std::formatter` class and its specializations. It also implements the following formatting functions: - `format` - `vformat` - `format_to` - `vformat_to` - `format_to_n` - `formatted_size` All functions have a `char` and `wchar_t` version. Parsing the format-spec and using the parsed format-spec hasn't been implemented. The code isn't optimized, neither for speed, nor for size. The goal is to have the rudimentary basics working, which can be used as a basis to improve upon. The formatters used in this commit are simple stubs that will be replaced by real formatters in later commits. The formatters that are slated to be replaced in this patch series don't have an availability macro to avoid merge conflicts. Note the formatter for `bool` uses `0` and `1` instead of "false" and "true". This will be fixed when the stub is replaced with a real formatter. Implements parts of: - P0645 Text Formatting Completes: - LWG3539 format_to must not copy models of output_iterator<const charT&> Reviewed By: ldionne, #libc, vitaut Differential Revision: https://reviews.llvm.org/D96664
2020-12-19 20:52:07 +08:00
}
[libc++] Add an option to disable wide character support in libc++ 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. Differential Revision: https://reviews.llvm.org/D111265
2021-08-24 03:32:36 +08:00
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
[libc++][format] Implement formatters. This implements the initial version of the `std::formatter` class and its specializations. It also implements the following formatting functions: - `format` - `vformat` - `format_to` - `vformat_to` - `format_to_n` - `formatted_size` All functions have a `char` and `wchar_t` version. Parsing the format-spec and using the parsed format-spec hasn't been implemented. The code isn't optimized, neither for speed, nor for size. The goal is to have the rudimentary basics working, which can be used as a basis to improve upon. The formatters used in this commit are simple stubs that will be replaced by real formatters in later commits. The formatters that are slated to be replaced in this patch series don't have an availability macro to avoid merge conflicts. Note the formatter for `bool` uses `0` and `1` instead of "false" and "true". This will be fixed when the stub is replaced with a real formatter. Implements parts of: - P0645 Text Formatting Completes: - LWG3539 format_to must not copy models of output_iterator<const charT&> Reviewed By: ldionne, #libc, vitaut Differential Revision: https://reviews.llvm.org/D96664
2020-12-19 20:52:07 +08:00
template <output_iterator<const wchar_t&> _OutIt, class... _Args>
[libc++][format][1/6] Reduce binary size. This removes the `format_args_t` from `<format>` and adjusts the type of the `format_args` for the `vformat_to` overloads. The `format_context` uses a `back_insert_iterator<string>` therefore the new `output_iterator` function uses a `string` as its temporary storage buffer. This isn't ideal. The next patches in this series will improve this. These improvements make it easy to also improve `format_to_n` and `formatted_size`. This addresses P2216 `6. Binary size`. P2216 `5. Compile-time checks` are not part of this change. Implements parts of: - P2216 std::format improvements Depends on D103670 Reviewed By: ldionne, #libc Differential Revision: https://reviews.llvm.org/D110494
2021-09-04 19:26:58 +08:00
_LIBCPP_ALWAYS_INLINE _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT _OutIt
[libc++][format] Use forwarding references. This implements a not accepted LWG issue. Not doing so would require integral types to use the handle class instead of being directly stored in the basic_format_arg. The previous code used `std::forward` in places where it wasn't required by the Standard. These are now removed. Implements: - P2418R2 Add support for std::generator-like types to std::format - LWG 3631 basic_format_arg(T&&) should use remove_cvref_t<T> throughout Reviewed By: ldionne, #libc Differential Revision: https://reviews.llvm.org/D127570
2021-10-06 01:25:37 +08:00
format_to(_OutIt __out_it, __wformat_string_t<_Args...> __fmt, _Args&&... __args) {
[libc++][format] Implement format-string. Implements the compile-time checking of the formatting arguments. Completes: - P2216 std::format improvements Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D121530
2021-10-02 18:38:46 +08:00
return _VSTD::vformat_to(_VSTD::move(__out_it), __fmt.__str_,
[libc++][format][1/6] Reduce binary size. This removes the `format_args_t` from `<format>` and adjusts the type of the `format_args` for the `vformat_to` overloads. The `format_context` uses a `back_insert_iterator<string>` therefore the new `output_iterator` function uses a `string` as its temporary storage buffer. This isn't ideal. The next patches in this series will improve this. These improvements make it easy to also improve `format_to_n` and `formatted_size`. This addresses P2216 `6. Binary size`. P2216 `5. Compile-time checks` are not part of this change. Implements parts of: - P2216 std::format improvements Depends on D103670 Reviewed By: ldionne, #libc Differential Revision: https://reviews.llvm.org/D110494
2021-09-04 19:26:58 +08:00
_VSTD::make_wformat_args(__args...));
[libc++][format] Implement formatters. This implements the initial version of the `std::formatter` class and its specializations. It also implements the following formatting functions: - `format` - `vformat` - `format_to` - `vformat_to` - `format_to_n` - `formatted_size` All functions have a `char` and `wchar_t` version. Parsing the format-spec and using the parsed format-spec hasn't been implemented. The code isn't optimized, neither for speed, nor for size. The goal is to have the rudimentary basics working, which can be used as a basis to improve upon. The formatters used in this commit are simple stubs that will be replaced by real formatters in later commits. The formatters that are slated to be replaced in this patch series don't have an availability macro to avoid merge conflicts. Note the formatter for `bool` uses `0` and `1` instead of "false" and "true". This will be fixed when the stub is replaced with a real formatter. Implements parts of: - P0645 Text Formatting Completes: - LWG3539 format_to must not copy models of output_iterator<const charT&> Reviewed By: ldionne, #libc, vitaut Differential Revision: https://reviews.llvm.org/D96664
2020-12-19 20:52:07 +08:00
}
[libc++] Add an option to disable wide character support in libc++ 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. Differential Revision: https://reviews.llvm.org/D111265
2021-08-24 03:32:36 +08:00
#endif
[libc++][format] Implement formatters. This implements the initial version of the `std::formatter` class and its specializations. It also implements the following formatting functions: - `format` - `vformat` - `format_to` - `vformat_to` - `format_to_n` - `formatted_size` All functions have a `char` and `wchar_t` version. Parsing the format-spec and using the parsed format-spec hasn't been implemented. The code isn't optimized, neither for speed, nor for size. The goal is to have the rudimentary basics working, which can be used as a basis to improve upon. The formatters used in this commit are simple stubs that will be replaced by real formatters in later commits. The formatters that are slated to be replaced in this patch series don't have an availability macro to avoid merge conflicts. Note the formatter for `bool` uses `0` and `1` instead of "false" and "true". This will be fixed when the stub is replaced with a real formatter. Implements parts of: - P0645 Text Formatting Completes: - LWG3539 format_to must not copy models of output_iterator<const charT&> Reviewed By: ldionne, #libc, vitaut Differential Revision: https://reviews.llvm.org/D96664
2020-12-19 20:52:07 +08:00
[libc++][format][1/6] Reduce binary size. This removes the `format_args_t` from `<format>` and adjusts the type of the `format_args` for the `vformat_to` overloads. The `format_context` uses a `back_insert_iterator<string>` therefore the new `output_iterator` function uses a `string` as its temporary storage buffer. This isn't ideal. The next patches in this series will improve this. These improvements make it easy to also improve `format_to_n` and `formatted_size`. This addresses P2216 `6. Binary size`. P2216 `5. Compile-time checks` are not part of this change. Implements parts of: - P2216 std::format improvements Depends on D103670 Reviewed By: ldionne, #libc Differential Revision: https://reviews.llvm.org/D110494
2021-09-04 19:26:58 +08:00
_LIBCPP_ALWAYS_INLINE inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT string
[libc++][format] Implement formatters. This implements the initial version of the `std::formatter` class and its specializations. It also implements the following formatting functions: - `format` - `vformat` - `format_to` - `vformat_to` - `format_to_n` - `formatted_size` All functions have a `char` and `wchar_t` version. Parsing the format-spec and using the parsed format-spec hasn't been implemented. The code isn't optimized, neither for speed, nor for size. The goal is to have the rudimentary basics working, which can be used as a basis to improve upon. The formatters used in this commit are simple stubs that will be replaced by real formatters in later commits. The formatters that are slated to be replaced in this patch series don't have an availability macro to avoid merge conflicts. Note the formatter for `bool` uses `0` and `1` instead of "false" and "true". This will be fixed when the stub is replaced with a real formatter. Implements parts of: - P0645 Text Formatting Completes: - LWG3539 format_to must not copy models of output_iterator<const charT&> Reviewed By: ldionne, #libc, vitaut Differential Revision: https://reviews.llvm.org/D96664
2020-12-19 20:52:07 +08:00
vformat(string_view __fmt, format_args __args) {
string __res;
_VSTD::vformat_to(_VSTD::back_inserter(__res), __fmt, __args);
return __res;
}
[libc++] Add an option to disable wide character support in libc++ 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. Differential Revision: https://reviews.llvm.org/D111265
2021-08-24 03:32:36 +08:00
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
[libc++][format][1/6] Reduce binary size. This removes the `format_args_t` from `<format>` and adjusts the type of the `format_args` for the `vformat_to` overloads. The `format_context` uses a `back_insert_iterator<string>` therefore the new `output_iterator` function uses a `string` as its temporary storage buffer. This isn't ideal. The next patches in this series will improve this. These improvements make it easy to also improve `format_to_n` and `formatted_size`. This addresses P2216 `6. Binary size`. P2216 `5. Compile-time checks` are not part of this change. Implements parts of: - P2216 std::format improvements Depends on D103670 Reviewed By: ldionne, #libc Differential Revision: https://reviews.llvm.org/D110494
2021-09-04 19:26:58 +08:00
_LIBCPP_ALWAYS_INLINE inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT wstring
[libc++][format] Implement formatters. This implements the initial version of the `std::formatter` class and its specializations. It also implements the following formatting functions: - `format` - `vformat` - `format_to` - `vformat_to` - `format_to_n` - `formatted_size` All functions have a `char` and `wchar_t` version. Parsing the format-spec and using the parsed format-spec hasn't been implemented. The code isn't optimized, neither for speed, nor for size. The goal is to have the rudimentary basics working, which can be used as a basis to improve upon. The formatters used in this commit are simple stubs that will be replaced by real formatters in later commits. The formatters that are slated to be replaced in this patch series don't have an availability macro to avoid merge conflicts. Note the formatter for `bool` uses `0` and `1` instead of "false" and "true". This will be fixed when the stub is replaced with a real formatter. Implements parts of: - P0645 Text Formatting Completes: - LWG3539 format_to must not copy models of output_iterator<const charT&> Reviewed By: ldionne, #libc, vitaut Differential Revision: https://reviews.llvm.org/D96664
2020-12-19 20:52:07 +08:00
vformat(wstring_view __fmt, wformat_args __args) {
wstring __res;
_VSTD::vformat_to(_VSTD::back_inserter(__res), __fmt, __args);
return __res;
}
[libc++] Add an option to disable wide character support in libc++ 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. Differential Revision: https://reviews.llvm.org/D111265
2021-08-24 03:32:36 +08:00
#endif
[libc++][format] Implement formatters. This implements the initial version of the `std::formatter` class and its specializations. It also implements the following formatting functions: - `format` - `vformat` - `format_to` - `vformat_to` - `format_to_n` - `formatted_size` All functions have a `char` and `wchar_t` version. Parsing the format-spec and using the parsed format-spec hasn't been implemented. The code isn't optimized, neither for speed, nor for size. The goal is to have the rudimentary basics working, which can be used as a basis to improve upon. The formatters used in this commit are simple stubs that will be replaced by real formatters in later commits. The formatters that are slated to be replaced in this patch series don't have an availability macro to avoid merge conflicts. Note the formatter for `bool` uses `0` and `1` instead of "false" and "true". This will be fixed when the stub is replaced with a real formatter. Implements parts of: - P0645 Text Formatting Completes: - LWG3539 format_to must not copy models of output_iterator<const charT&> Reviewed By: ldionne, #libc, vitaut Differential Revision: https://reviews.llvm.org/D96664
2020-12-19 20:52:07 +08:00
template <class... _Args>
[libc++][format] Implement format-string. Implements the compile-time checking of the formatting arguments. Completes: - P2216 std::format improvements Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D121530
2021-10-02 18:38:46 +08:00
_LIBCPP_ALWAYS_INLINE _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT string format(__format_string_t<_Args...> __fmt,
[libc++][format] Use forwarding references. This implements a not accepted LWG issue. Not doing so would require integral types to use the handle class instead of being directly stored in the basic_format_arg. The previous code used `std::forward` in places where it wasn't required by the Standard. These are now removed. Implements: - P2418R2 Add support for std::generator-like types to std::format - LWG 3631 basic_format_arg(T&&) should use remove_cvref_t<T> throughout Reviewed By: ldionne, #libc Differential Revision: https://reviews.llvm.org/D127570
2021-10-06 01:25:37 +08:00
_Args&&... __args) {
[libc++][format] Implement format-string. Implements the compile-time checking of the formatting arguments. Completes: - P2216 std::format improvements Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D121530
2021-10-02 18:38:46 +08:00
return _VSTD::vformat(__fmt.__str_, _VSTD::make_format_args(__args...));
[libc++][format] Implement formatters. This implements the initial version of the `std::formatter` class and its specializations. It also implements the following formatting functions: - `format` - `vformat` - `format_to` - `vformat_to` - `format_to_n` - `formatted_size` All functions have a `char` and `wchar_t` version. Parsing the format-spec and using the parsed format-spec hasn't been implemented. The code isn't optimized, neither for speed, nor for size. The goal is to have the rudimentary basics working, which can be used as a basis to improve upon. The formatters used in this commit are simple stubs that will be replaced by real formatters in later commits. The formatters that are slated to be replaced in this patch series don't have an availability macro to avoid merge conflicts. Note the formatter for `bool` uses `0` and `1` instead of "false" and "true". This will be fixed when the stub is replaced with a real formatter. Implements parts of: - P0645 Text Formatting Completes: - LWG3539 format_to must not copy models of output_iterator<const charT&> Reviewed By: ldionne, #libc, vitaut Differential Revision: https://reviews.llvm.org/D96664
2020-12-19 20:52:07 +08:00
}
[libc++] Add an option to disable wide character support in libc++ 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. Differential Revision: https://reviews.llvm.org/D111265
2021-08-24 03:32:36 +08:00
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
[libc++][format] Implement formatters. This implements the initial version of the `std::formatter` class and its specializations. It also implements the following formatting functions: - `format` - `vformat` - `format_to` - `vformat_to` - `format_to_n` - `formatted_size` All functions have a `char` and `wchar_t` version. Parsing the format-spec and using the parsed format-spec hasn't been implemented. The code isn't optimized, neither for speed, nor for size. The goal is to have the rudimentary basics working, which can be used as a basis to improve upon. The formatters used in this commit are simple stubs that will be replaced by real formatters in later commits. The formatters that are slated to be replaced in this patch series don't have an availability macro to avoid merge conflicts. Note the formatter for `bool` uses `0` and `1` instead of "false" and "true". This will be fixed when the stub is replaced with a real formatter. Implements parts of: - P0645 Text Formatting Completes: - LWG3539 format_to must not copy models of output_iterator<const charT&> Reviewed By: ldionne, #libc, vitaut Differential Revision: https://reviews.llvm.org/D96664
2020-12-19 20:52:07 +08:00
template <class... _Args>
[libc++][format][1/6] Reduce binary size. This removes the `format_args_t` from `<format>` and adjusts the type of the `format_args` for the `vformat_to` overloads. The `format_context` uses a `back_insert_iterator<string>` therefore the new `output_iterator` function uses a `string` as its temporary storage buffer. This isn't ideal. The next patches in this series will improve this. These improvements make it easy to also improve `format_to_n` and `formatted_size`. This addresses P2216 `6. Binary size`. P2216 `5. Compile-time checks` are not part of this change. Implements parts of: - P2216 std::format improvements Depends on D103670 Reviewed By: ldionne, #libc Differential Revision: https://reviews.llvm.org/D110494
2021-09-04 19:26:58 +08:00
_LIBCPP_ALWAYS_INLINE _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT wstring
[libc++][format] Use forwarding references. This implements a not accepted LWG issue. Not doing so would require integral types to use the handle class instead of being directly stored in the basic_format_arg. The previous code used `std::forward` in places where it wasn't required by the Standard. These are now removed. Implements: - P2418R2 Add support for std::generator-like types to std::format - LWG 3631 basic_format_arg(T&&) should use remove_cvref_t<T> throughout Reviewed By: ldionne, #libc Differential Revision: https://reviews.llvm.org/D127570
2021-10-06 01:25:37 +08:00
format(__wformat_string_t<_Args...> __fmt, _Args&&... __args) {
[libc++][format] Implement format-string. Implements the compile-time checking of the formatting arguments. Completes: - P2216 std::format improvements Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D121530
2021-10-02 18:38:46 +08:00
return _VSTD::vformat(__fmt.__str_, _VSTD::make_wformat_args(__args...));
[libc++][format] Implement formatters. This implements the initial version of the `std::formatter` class and its specializations. It also implements the following formatting functions: - `format` - `vformat` - `format_to` - `vformat_to` - `format_to_n` - `formatted_size` All functions have a `char` and `wchar_t` version. Parsing the format-spec and using the parsed format-spec hasn't been implemented. The code isn't optimized, neither for speed, nor for size. The goal is to have the rudimentary basics working, which can be used as a basis to improve upon. The formatters used in this commit are simple stubs that will be replaced by real formatters in later commits. The formatters that are slated to be replaced in this patch series don't have an availability macro to avoid merge conflicts. Note the formatter for `bool` uses `0` and `1` instead of "false" and "true". This will be fixed when the stub is replaced with a real formatter. Implements parts of: - P0645 Text Formatting Completes: - LWG3539 format_to must not copy models of output_iterator<const charT&> Reviewed By: ldionne, #libc, vitaut Differential Revision: https://reviews.llvm.org/D96664
2020-12-19 20:52:07 +08:00
}
[libc++] Add an option to disable wide character support in libc++ 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. Differential Revision: https://reviews.llvm.org/D111265
2021-08-24 03:32:36 +08:00
#endif
[libc++][format] Implement formatters. This implements the initial version of the `std::formatter` class and its specializations. It also implements the following formatting functions: - `format` - `vformat` - `format_to` - `vformat_to` - `format_to_n` - `formatted_size` All functions have a `char` and `wchar_t` version. Parsing the format-spec and using the parsed format-spec hasn't been implemented. The code isn't optimized, neither for speed, nor for size. The goal is to have the rudimentary basics working, which can be used as a basis to improve upon. The formatters used in this commit are simple stubs that will be replaced by real formatters in later commits. The formatters that are slated to be replaced in this patch series don't have an availability macro to avoid merge conflicts. Note the formatter for `bool` uses `0` and `1` instead of "false" and "true". This will be fixed when the stub is replaced with a real formatter. Implements parts of: - P0645 Text Formatting Completes: - LWG3539 format_to must not copy models of output_iterator<const charT&> Reviewed By: ldionne, #libc, vitaut Differential Revision: https://reviews.llvm.org/D96664
2020-12-19 20:52:07 +08:00
[libc++][format][5/6] Improve format_to_n. Use a specialized buffer wrapper to limit the number of insertions in the buffer. After the limit has been reached the buffer only needs to count the number of insertions to return the buffer size required to store the entire output. Depends on D110498 Reviewed By: #libc, Mordante Differential Revision: https://reviews.llvm.org/D110499
2021-09-26 23:04:53 +08:00
template <class _Context, class _OutIt, class _CharT>
_LIBCPP_HIDE_FROM_ABI format_to_n_result<_OutIt> __vformat_to_n(_OutIt __out_it, iter_difference_t<_OutIt> __n,
basic_string_view<_CharT> __fmt,
basic_format_args<_Context> __args) {
__format::__format_to_n_buffer<_OutIt, _CharT> __buffer{_VSTD::move(__out_it), __n};
_VSTD::__format::__vformat_to(basic_format_parse_context{__fmt, __args.__size()},
_VSTD::__format_context_create(__buffer.make_output_iterator(), __args));
return _VSTD::move(__buffer).result();
}
[libc++][format] Implement formatters. This implements the initial version of the `std::formatter` class and its specializations. It also implements the following formatting functions: - `format` - `vformat` - `format_to` - `vformat_to` - `format_to_n` - `formatted_size` All functions have a `char` and `wchar_t` version. Parsing the format-spec and using the parsed format-spec hasn't been implemented. The code isn't optimized, neither for speed, nor for size. The goal is to have the rudimentary basics working, which can be used as a basis to improve upon. The formatters used in this commit are simple stubs that will be replaced by real formatters in later commits. The formatters that are slated to be replaced in this patch series don't have an availability macro to avoid merge conflicts. Note the formatter for `bool` uses `0` and `1` instead of "false" and "true". This will be fixed when the stub is replaced with a real formatter. Implements parts of: - P0645 Text Formatting Completes: - LWG3539 format_to must not copy models of output_iterator<const charT&> Reviewed By: ldionne, #libc, vitaut Differential Revision: https://reviews.llvm.org/D96664
2020-12-19 20:52:07 +08:00
template <output_iterator<const char&> _OutIt, class... _Args>
[libc++][format][5/6] Improve format_to_n. Use a specialized buffer wrapper to limit the number of insertions in the buffer. After the limit has been reached the buffer only needs to count the number of insertions to return the buffer size required to store the entire output. Depends on D110498 Reviewed By: #libc, Mordante Differential Revision: https://reviews.llvm.org/D110499
2021-09-26 23:04:53 +08:00
_LIBCPP_ALWAYS_INLINE _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT format_to_n_result<_OutIt>
[libc++][format] Use forwarding references. This implements a not accepted LWG issue. Not doing so would require integral types to use the handle class instead of being directly stored in the basic_format_arg. The previous code used `std::forward` in places where it wasn't required by the Standard. These are now removed. Implements: - P2418R2 Add support for std::generator-like types to std::format - LWG 3631 basic_format_arg(T&&) should use remove_cvref_t<T> throughout Reviewed By: ldionne, #libc Differential Revision: https://reviews.llvm.org/D127570
2021-10-06 01:25:37 +08:00
format_to_n(_OutIt __out_it, iter_difference_t<_OutIt> __n, __format_string_t<_Args...> __fmt, _Args&&... __args) {
[libc++][format] Implement format-string. Implements the compile-time checking of the formatting arguments. Completes: - P2216 std::format improvements Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D121530
2021-10-02 18:38:46 +08:00
return _VSTD::__vformat_to_n<format_context>(_VSTD::move(__out_it), __n, __fmt.__str_, _VSTD::make_format_args(__args...));
[libc++][format] Implement formatters. This implements the initial version of the `std::formatter` class and its specializations. It also implements the following formatting functions: - `format` - `vformat` - `format_to` - `vformat_to` - `format_to_n` - `formatted_size` All functions have a `char` and `wchar_t` version. Parsing the format-spec and using the parsed format-spec hasn't been implemented. The code isn't optimized, neither for speed, nor for size. The goal is to have the rudimentary basics working, which can be used as a basis to improve upon. The formatters used in this commit are simple stubs that will be replaced by real formatters in later commits. The formatters that are slated to be replaced in this patch series don't have an availability macro to avoid merge conflicts. Note the formatter for `bool` uses `0` and `1` instead of "false" and "true". This will be fixed when the stub is replaced with a real formatter. Implements parts of: - P0645 Text Formatting Completes: - LWG3539 format_to must not copy models of output_iterator<const charT&> Reviewed By: ldionne, #libc, vitaut Differential Revision: https://reviews.llvm.org/D96664
2020-12-19 20:52:07 +08:00
}
[libc++] Add an option to disable wide character support in libc++ 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. Differential Revision: https://reviews.llvm.org/D111265
2021-08-24 03:32:36 +08:00
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
[libc++][format] Implement formatters. This implements the initial version of the `std::formatter` class and its specializations. It also implements the following formatting functions: - `format` - `vformat` - `format_to` - `vformat_to` - `format_to_n` - `formatted_size` All functions have a `char` and `wchar_t` version. Parsing the format-spec and using the parsed format-spec hasn't been implemented. The code isn't optimized, neither for speed, nor for size. The goal is to have the rudimentary basics working, which can be used as a basis to improve upon. The formatters used in this commit are simple stubs that will be replaced by real formatters in later commits. The formatters that are slated to be replaced in this patch series don't have an availability macro to avoid merge conflicts. Note the formatter for `bool` uses `0` and `1` instead of "false" and "true". This will be fixed when the stub is replaced with a real formatter. Implements parts of: - P0645 Text Formatting Completes: - LWG3539 format_to must not copy models of output_iterator<const charT&> Reviewed By: ldionne, #libc, vitaut Differential Revision: https://reviews.llvm.org/D96664
2020-12-19 20:52:07 +08:00
template <output_iterator<const wchar_t&> _OutIt, class... _Args>
[libc++][format] Implement format-string. Implements the compile-time checking of the formatting arguments. Completes: - P2216 std::format improvements Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D121530
2021-10-02 18:38:46 +08:00
_LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT format_to_n_result<_OutIt>
format_to_n(_OutIt __out_it, iter_difference_t<_OutIt> __n, __wformat_string_t<_Args...> __fmt,
[libc++][format] Use forwarding references. This implements a not accepted LWG issue. Not doing so would require integral types to use the handle class instead of being directly stored in the basic_format_arg. The previous code used `std::forward` in places where it wasn't required by the Standard. These are now removed. Implements: - P2418R2 Add support for std::generator-like types to std::format - LWG 3631 basic_format_arg(T&&) should use remove_cvref_t<T> throughout Reviewed By: ldionne, #libc Differential Revision: https://reviews.llvm.org/D127570
2021-10-06 01:25:37 +08:00
_Args&&... __args) {
[libc++][format] Implement format-string. Implements the compile-time checking of the formatting arguments. Completes: - P2216 std::format improvements Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D121530
2021-10-02 18:38:46 +08:00
return _VSTD::__vformat_to_n<wformat_context>(_VSTD::move(__out_it), __n, __fmt.__str_, _VSTD::make_wformat_args(__args...));
[libc++][format] Implement formatters. This implements the initial version of the `std::formatter` class and its specializations. It also implements the following formatting functions: - `format` - `vformat` - `format_to` - `vformat_to` - `format_to_n` - `formatted_size` All functions have a `char` and `wchar_t` version. Parsing the format-spec and using the parsed format-spec hasn't been implemented. The code isn't optimized, neither for speed, nor for size. The goal is to have the rudimentary basics working, which can be used as a basis to improve upon. The formatters used in this commit are simple stubs that will be replaced by real formatters in later commits. The formatters that are slated to be replaced in this patch series don't have an availability macro to avoid merge conflicts. Note the formatter for `bool` uses `0` and `1` instead of "false" and "true". This will be fixed when the stub is replaced with a real formatter. Implements parts of: - P0645 Text Formatting Completes: - LWG3539 format_to must not copy models of output_iterator<const charT&> Reviewed By: ldionne, #libc, vitaut Differential Revision: https://reviews.llvm.org/D96664
2020-12-19 20:52:07 +08:00
}
[libc++] Add an option to disable wide character support in libc++ 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. Differential Revision: https://reviews.llvm.org/D111265
2021-08-24 03:32:36 +08:00
#endif
[libc++][format] Implement formatters. This implements the initial version of the `std::formatter` class and its specializations. It also implements the following formatting functions: - `format` - `vformat` - `format_to` - `vformat_to` - `format_to_n` - `formatted_size` All functions have a `char` and `wchar_t` version. Parsing the format-spec and using the parsed format-spec hasn't been implemented. The code isn't optimized, neither for speed, nor for size. The goal is to have the rudimentary basics working, which can be used as a basis to improve upon. The formatters used in this commit are simple stubs that will be replaced by real formatters in later commits. The formatters that are slated to be replaced in this patch series don't have an availability macro to avoid merge conflicts. Note the formatter for `bool` uses `0` and `1` instead of "false" and "true". This will be fixed when the stub is replaced with a real formatter. Implements parts of: - P0645 Text Formatting Completes: - LWG3539 format_to must not copy models of output_iterator<const charT&> Reviewed By: ldionne, #libc, vitaut Differential Revision: https://reviews.llvm.org/D96664
2020-12-19 20:52:07 +08:00
[libc++][format][4/6] Improve formatted_size. Use a specialized "buffer" to count the number of insertions instead of using a `string` as storage type. Depends on D110497. Reviewed By: ldionne, #libc Differential Revision: https://reviews.llvm.org/D110498
2021-09-26 22:48:25 +08:00
template <class _CharT>
_LIBCPP_HIDE_FROM_ABI size_t __vformatted_size(basic_string_view<_CharT> __fmt, auto __args) {
__format::__formatted_size_buffer<_CharT> __buffer;
_VSTD::__format::__vformat_to(basic_format_parse_context{__fmt, __args.__size()},
_VSTD::__format_context_create(__buffer.make_output_iterator(), __args));
return _VSTD::move(__buffer).result();
}
[libc++][format] Implement formatters. This implements the initial version of the `std::formatter` class and its specializations. It also implements the following formatting functions: - `format` - `vformat` - `format_to` - `vformat_to` - `format_to_n` - `formatted_size` All functions have a `char` and `wchar_t` version. Parsing the format-spec and using the parsed format-spec hasn't been implemented. The code isn't optimized, neither for speed, nor for size. The goal is to have the rudimentary basics working, which can be used as a basis to improve upon. The formatters used in this commit are simple stubs that will be replaced by real formatters in later commits. The formatters that are slated to be replaced in this patch series don't have an availability macro to avoid merge conflicts. Note the formatter for `bool` uses `0` and `1` instead of "false" and "true". This will be fixed when the stub is replaced with a real formatter. Implements parts of: - P0645 Text Formatting Completes: - LWG3539 format_to must not copy models of output_iterator<const charT&> Reviewed By: ldionne, #libc, vitaut Differential Revision: https://reviews.llvm.org/D96664
2020-12-19 20:52:07 +08:00
template <class... _Args>
[libc++][format] Implement format-string. Implements the compile-time checking of the formatting arguments. Completes: - P2216 std::format improvements Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D121530
2021-10-02 18:38:46 +08:00
_LIBCPP_ALWAYS_INLINE _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT size_t
[libc++][format] Use forwarding references. This implements a not accepted LWG issue. Not doing so would require integral types to use the handle class instead of being directly stored in the basic_format_arg. The previous code used `std::forward` in places where it wasn't required by the Standard. These are now removed. Implements: - P2418R2 Add support for std::generator-like types to std::format - LWG 3631 basic_format_arg(T&&) should use remove_cvref_t<T> throughout Reviewed By: ldionne, #libc Differential Revision: https://reviews.llvm.org/D127570
2021-10-06 01:25:37 +08:00
formatted_size(__format_string_t<_Args...> __fmt, _Args&&... __args) {
[libc++][format] Implement format-string. Implements the compile-time checking of the formatting arguments. Completes: - P2216 std::format improvements Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D121530
2021-10-02 18:38:46 +08:00
return _VSTD::__vformatted_size(__fmt.__str_, basic_format_args{_VSTD::make_format_args(__args...)});
[libc++][format] Implement formatters. This implements the initial version of the `std::formatter` class and its specializations. It also implements the following formatting functions: - `format` - `vformat` - `format_to` - `vformat_to` - `format_to_n` - `formatted_size` All functions have a `char` and `wchar_t` version. Parsing the format-spec and using the parsed format-spec hasn't been implemented. The code isn't optimized, neither for speed, nor for size. The goal is to have the rudimentary basics working, which can be used as a basis to improve upon. The formatters used in this commit are simple stubs that will be replaced by real formatters in later commits. The formatters that are slated to be replaced in this patch series don't have an availability macro to avoid merge conflicts. Note the formatter for `bool` uses `0` and `1` instead of "false" and "true". This will be fixed when the stub is replaced with a real formatter. Implements parts of: - P0645 Text Formatting Completes: - LWG3539 format_to must not copy models of output_iterator<const charT&> Reviewed By: ldionne, #libc, vitaut Differential Revision: https://reviews.llvm.org/D96664
2020-12-19 20:52:07 +08:00
}
[libc++] Add an option to disable wide character support in libc++ 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. Differential Revision: https://reviews.llvm.org/D111265
2021-08-24 03:32:36 +08:00
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
[libc++][format] Implement formatters. This implements the initial version of the `std::formatter` class and its specializations. It also implements the following formatting functions: - `format` - `vformat` - `format_to` - `vformat_to` - `format_to_n` - `formatted_size` All functions have a `char` and `wchar_t` version. Parsing the format-spec and using the parsed format-spec hasn't been implemented. The code isn't optimized, neither for speed, nor for size. The goal is to have the rudimentary basics working, which can be used as a basis to improve upon. The formatters used in this commit are simple stubs that will be replaced by real formatters in later commits. The formatters that are slated to be replaced in this patch series don't have an availability macro to avoid merge conflicts. Note the formatter for `bool` uses `0` and `1` instead of "false" and "true". This will be fixed when the stub is replaced with a real formatter. Implements parts of: - P0645 Text Formatting Completes: - LWG3539 format_to must not copy models of output_iterator<const charT&> Reviewed By: ldionne, #libc, vitaut Differential Revision: https://reviews.llvm.org/D96664
2020-12-19 20:52:07 +08:00
template <class... _Args>
[libc++][format] Implement format-string. Implements the compile-time checking of the formatting arguments. Completes: - P2216 std::format improvements Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D121530
2021-10-02 18:38:46 +08:00
_LIBCPP_ALWAYS_INLINE _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT size_t
[libc++][format] Use forwarding references. This implements a not accepted LWG issue. Not doing so would require integral types to use the handle class instead of being directly stored in the basic_format_arg. The previous code used `std::forward` in places where it wasn't required by the Standard. These are now removed. Implements: - P2418R2 Add support for std::generator-like types to std::format - LWG 3631 basic_format_arg(T&&) should use remove_cvref_t<T> throughout Reviewed By: ldionne, #libc Differential Revision: https://reviews.llvm.org/D127570
2021-10-06 01:25:37 +08:00
formatted_size(__wformat_string_t<_Args...> __fmt, _Args&&... __args) {
[libc++][format] Implement format-string. Implements the compile-time checking of the formatting arguments. Completes: - P2216 std::format improvements Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D121530
2021-10-02 18:38:46 +08:00
return _VSTD::__vformatted_size(__fmt.__str_, basic_format_args{_VSTD::make_wformat_args(__args...)});
[libc++][format] Implement formatters. This implements the initial version of the `std::formatter` class and its specializations. It also implements the following formatting functions: - `format` - `vformat` - `format_to` - `vformat_to` - `format_to_n` - `formatted_size` All functions have a `char` and `wchar_t` version. Parsing the format-spec and using the parsed format-spec hasn't been implemented. The code isn't optimized, neither for speed, nor for size. The goal is to have the rudimentary basics working, which can be used as a basis to improve upon. The formatters used in this commit are simple stubs that will be replaced by real formatters in later commits. The formatters that are slated to be replaced in this patch series don't have an availability macro to avoid merge conflicts. Note the formatter for `bool` uses `0` and `1` instead of "false" and "true". This will be fixed when the stub is replaced with a real formatter. Implements parts of: - P0645 Text Formatting Completes: - LWG3539 format_to must not copy models of output_iterator<const charT&> Reviewed By: ldionne, #libc, vitaut Differential Revision: https://reviews.llvm.org/D96664
2020-12-19 20:52:07 +08:00
}
[libc++] Add an option to disable wide character support in libc++ 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. Differential Revision: https://reviews.llvm.org/D111265
2021-08-24 03:32:36 +08:00
#endif
[libc++][format] Implement formatters. This implements the initial version of the `std::formatter` class and its specializations. It also implements the following formatting functions: - `format` - `vformat` - `format_to` - `vformat_to` - `format_to_n` - `formatted_size` All functions have a `char` and `wchar_t` version. Parsing the format-spec and using the parsed format-spec hasn't been implemented. The code isn't optimized, neither for speed, nor for size. The goal is to have the rudimentary basics working, which can be used as a basis to improve upon. The formatters used in this commit are simple stubs that will be replaced by real formatters in later commits. The formatters that are slated to be replaced in this patch series don't have an availability macro to avoid merge conflicts. Note the formatter for `bool` uses `0` and `1` instead of "false" and "true". This will be fixed when the stub is replaced with a real formatter. Implements parts of: - P0645 Text Formatting Completes: - LWG3539 format_to must not copy models of output_iterator<const charT&> Reviewed By: ldionne, #libc, vitaut Differential Revision: https://reviews.llvm.org/D96664
2020-12-19 20:52:07 +08:00
#ifndef _LIBCPP_HAS_NO_LOCALIZATION
[libc++][format][1/6] Reduce binary size. This removes the `format_args_t` from `<format>` and adjusts the type of the `format_args` for the `vformat_to` overloads. The `format_context` uses a `back_insert_iterator<string>` therefore the new `output_iterator` function uses a `string` as its temporary storage buffer. This isn't ideal. The next patches in this series will improve this. These improvements make it easy to also improve `format_to_n` and `formatted_size`. This addresses P2216 `6. Binary size`. P2216 `5. Compile-time checks` are not part of this change. Implements parts of: - P2216 std::format improvements Depends on D103670 Reviewed By: ldionne, #libc Differential Revision: https://reviews.llvm.org/D110494
2021-09-04 19:26:58 +08:00
template <class _OutIt, class _CharT, class _FormatOutIt>
[libc++][format] Implement formatters. This implements the initial version of the `std::formatter` class and its specializations. It also implements the following formatting functions: - `format` - `vformat` - `format_to` - `vformat_to` - `format_to_n` - `formatted_size` All functions have a `char` and `wchar_t` version. Parsing the format-spec and using the parsed format-spec hasn't been implemented. The code isn't optimized, neither for speed, nor for size. The goal is to have the rudimentary basics working, which can be used as a basis to improve upon. The formatters used in this commit are simple stubs that will be replaced by real formatters in later commits. The formatters that are slated to be replaced in this patch series don't have an availability macro to avoid merge conflicts. Note the formatter for `bool` uses `0` and `1` instead of "false" and "true". This will be fixed when the stub is replaced with a real formatter. Implements parts of: - P0645 Text Formatting Completes: - LWG3539 format_to must not copy models of output_iterator<const charT&> Reviewed By: ldionne, #libc, vitaut Differential Revision: https://reviews.llvm.org/D96664
2020-12-19 20:52:07 +08:00
requires(output_iterator<_OutIt, const _CharT&>) _LIBCPP_HIDE_FROM_ABI _OutIt
[libc++][format][1/6] Reduce binary size. This removes the `format_args_t` from `<format>` and adjusts the type of the `format_args` for the `vformat_to` overloads. The `format_context` uses a `back_insert_iterator<string>` therefore the new `output_iterator` function uses a `string` as its temporary storage buffer. This isn't ideal. The next patches in this series will improve this. These improvements make it easy to also improve `format_to_n` and `formatted_size`. This addresses P2216 `6. Binary size`. P2216 `5. Compile-time checks` are not part of this change. Implements parts of: - P2216 std::format improvements Depends on D103670 Reviewed By: ldionne, #libc Differential Revision: https://reviews.llvm.org/D110494
2021-09-04 19:26:58 +08:00
__vformat_to(
_OutIt __out_it, locale __loc, basic_string_view<_CharT> __fmt,
basic_format_args<basic_format_context<_FormatOutIt, _CharT>> __args) {
if constexpr (same_as<_OutIt, _FormatOutIt>)
return _VSTD::__format::__vformat_to(
basic_format_parse_context{__fmt, __args.__size()},
_VSTD::__format_context_create(_VSTD::move(__out_it), __args,
_VSTD::move(__loc)));
else {
[libc++][format][2/6] Adds a __output_iterator. Instead of using a temporary `string` in `__vformat_to_wrapped` use a new generic iterator. This aids to reduce the number of template instantions and avoids using a `string` to buffer the entire formatted output. This changes the type of `format_context` and `wformat_context`, this can still be done since the code isn't ABI stable yet. Several approaches have been evaluated: - Using a __output_buffer base class with: - a put function to store the buffer in its internal buffer - a virtual flush function to copy the internal buffer to the output - Using a `function` to forward the output operation to the output buffer, much like the next method. - Using a type erased function point to store the data in the buffer. The last version resulted in the best performance. For some cases there's still a loss of speed over the original method. This loss many becomes apparent when large strings are copied to a pointer like iterator, before the compiler optimized this using `memcpy`. Reviewed By: ldionne, vitaut, #libc Differential Revision: https://reviews.llvm.org/D110495
2021-09-05 03:05:23 +08:00
__format::__format_buffer<_OutIt, _CharT> __buffer{_VSTD::move(__out_it)};
[libc++][format][1/6] Reduce binary size. This removes the `format_args_t` from `<format>` and adjusts the type of the `format_args` for the `vformat_to` overloads. The `format_context` uses a `back_insert_iterator<string>` therefore the new `output_iterator` function uses a `string` as its temporary storage buffer. This isn't ideal. The next patches in this series will improve this. These improvements make it easy to also improve `format_to_n` and `formatted_size`. This addresses P2216 `6. Binary size`. P2216 `5. Compile-time checks` are not part of this change. Implements parts of: - P2216 std::format improvements Depends on D103670 Reviewed By: ldionne, #libc Differential Revision: https://reviews.llvm.org/D110494
2021-09-04 19:26:58 +08:00
_VSTD::__format::__vformat_to(
basic_format_parse_context{__fmt, __args.__size()},
[libc++][format][2/6] Adds a __output_iterator. Instead of using a temporary `string` in `__vformat_to_wrapped` use a new generic iterator. This aids to reduce the number of template instantions and avoids using a `string` to buffer the entire formatted output. This changes the type of `format_context` and `wformat_context`, this can still be done since the code isn't ABI stable yet. Several approaches have been evaluated: - Using a __output_buffer base class with: - a put function to store the buffer in its internal buffer - a virtual flush function to copy the internal buffer to the output - Using a `function` to forward the output operation to the output buffer, much like the next method. - Using a type erased function point to store the data in the buffer. The last version resulted in the best performance. For some cases there's still a loss of speed over the original method. This loss many becomes apparent when large strings are copied to a pointer like iterator, before the compiler optimized this using `memcpy`. Reviewed By: ldionne, vitaut, #libc Differential Revision: https://reviews.llvm.org/D110495
2021-09-05 03:05:23 +08:00
_VSTD::__format_context_create(__buffer.make_output_iterator(),
__args, _VSTD::move(__loc)));
return _VSTD::move(__buffer).out();
[libc++][format][1/6] Reduce binary size. This removes the `format_args_t` from `<format>` and adjusts the type of the `format_args` for the `vformat_to` overloads. The `format_context` uses a `back_insert_iterator<string>` therefore the new `output_iterator` function uses a `string` as its temporary storage buffer. This isn't ideal. The next patches in this series will improve this. These improvements make it easy to also improve `format_to_n` and `formatted_size`. This addresses P2216 `6. Binary size`. P2216 `5. Compile-time checks` are not part of this change. Implements parts of: - P2216 std::format improvements Depends on D103670 Reviewed By: ldionne, #libc Differential Revision: https://reviews.llvm.org/D110494
2021-09-04 19:26:58 +08:00
}
[libc++][format] Implement formatters. This implements the initial version of the `std::formatter` class and its specializations. It also implements the following formatting functions: - `format` - `vformat` - `format_to` - `vformat_to` - `format_to_n` - `formatted_size` All functions have a `char` and `wchar_t` version. Parsing the format-spec and using the parsed format-spec hasn't been implemented. The code isn't optimized, neither for speed, nor for size. The goal is to have the rudimentary basics working, which can be used as a basis to improve upon. The formatters used in this commit are simple stubs that will be replaced by real formatters in later commits. The formatters that are slated to be replaced in this patch series don't have an availability macro to avoid merge conflicts. Note the formatter for `bool` uses `0` and `1` instead of "false" and "true". This will be fixed when the stub is replaced with a real formatter. Implements parts of: - P0645 Text Formatting Completes: - LWG3539 format_to must not copy models of output_iterator<const charT&> Reviewed By: ldionne, #libc, vitaut Differential Revision: https://reviews.llvm.org/D96664
2020-12-19 20:52:07 +08:00
}
template <output_iterator<const char&> _OutIt>
[libc++][format][1/6] Reduce binary size. This removes the `format_args_t` from `<format>` and adjusts the type of the `format_args` for the `vformat_to` overloads. The `format_context` uses a `back_insert_iterator<string>` therefore the new `output_iterator` function uses a `string` as its temporary storage buffer. This isn't ideal. The next patches in this series will improve this. These improvements make it easy to also improve `format_to_n` and `formatted_size`. This addresses P2216 `6. Binary size`. P2216 `5. Compile-time checks` are not part of this change. Implements parts of: - P2216 std::format improvements Depends on D103670 Reviewed By: ldionne, #libc Differential Revision: https://reviews.llvm.org/D110494
2021-09-04 19:26:58 +08:00
_LIBCPP_ALWAYS_INLINE _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT _OutIt vformat_to(
_OutIt __out_it, locale __loc, string_view __fmt, format_args __args) {
[libc++][format] Implement formatters. This implements the initial version of the `std::formatter` class and its specializations. It also implements the following formatting functions: - `format` - `vformat` - `format_to` - `vformat_to` - `format_to_n` - `formatted_size` All functions have a `char` and `wchar_t` version. Parsing the format-spec and using the parsed format-spec hasn't been implemented. The code isn't optimized, neither for speed, nor for size. The goal is to have the rudimentary basics working, which can be used as a basis to improve upon. The formatters used in this commit are simple stubs that will be replaced by real formatters in later commits. The formatters that are slated to be replaced in this patch series don't have an availability macro to avoid merge conflicts. Note the formatter for `bool` uses `0` and `1` instead of "false" and "true". This will be fixed when the stub is replaced with a real formatter. Implements parts of: - P0645 Text Formatting Completes: - LWG3539 format_to must not copy models of output_iterator<const charT&> Reviewed By: ldionne, #libc, vitaut Differential Revision: https://reviews.llvm.org/D96664
2020-12-19 20:52:07 +08:00
return _VSTD::__vformat_to(_VSTD::move(__out_it), _VSTD::move(__loc), __fmt,
__args);
}
[libc++] Add an option to disable wide character support in libc++ 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. Differential Revision: https://reviews.llvm.org/D111265
2021-08-24 03:32:36 +08:00
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
[libc++][format] Implement formatters. This implements the initial version of the `std::formatter` class and its specializations. It also implements the following formatting functions: - `format` - `vformat` - `format_to` - `vformat_to` - `format_to_n` - `formatted_size` All functions have a `char` and `wchar_t` version. Parsing the format-spec and using the parsed format-spec hasn't been implemented. The code isn't optimized, neither for speed, nor for size. The goal is to have the rudimentary basics working, which can be used as a basis to improve upon. The formatters used in this commit are simple stubs that will be replaced by real formatters in later commits. The formatters that are slated to be replaced in this patch series don't have an availability macro to avoid merge conflicts. Note the formatter for `bool` uses `0` and `1` instead of "false" and "true". This will be fixed when the stub is replaced with a real formatter. Implements parts of: - P0645 Text Formatting Completes: - LWG3539 format_to must not copy models of output_iterator<const charT&> Reviewed By: ldionne, #libc, vitaut Differential Revision: https://reviews.llvm.org/D96664
2020-12-19 20:52:07 +08:00
template <output_iterator<const wchar_t&> _OutIt>
[libc++][format][1/6] Reduce binary size. This removes the `format_args_t` from `<format>` and adjusts the type of the `format_args` for the `vformat_to` overloads. The `format_context` uses a `back_insert_iterator<string>` therefore the new `output_iterator` function uses a `string` as its temporary storage buffer. This isn't ideal. The next patches in this series will improve this. These improvements make it easy to also improve `format_to_n` and `formatted_size`. This addresses P2216 `6. Binary size`. P2216 `5. Compile-time checks` are not part of this change. Implements parts of: - P2216 std::format improvements Depends on D103670 Reviewed By: ldionne, #libc Differential Revision: https://reviews.llvm.org/D110494
2021-09-04 19:26:58 +08:00
_LIBCPP_ALWAYS_INLINE _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT _OutIt vformat_to(
_OutIt __out_it, locale __loc, wstring_view __fmt, wformat_args __args) {
[libc++][format] Implement formatters. This implements the initial version of the `std::formatter` class and its specializations. It also implements the following formatting functions: - `format` - `vformat` - `format_to` - `vformat_to` - `format_to_n` - `formatted_size` All functions have a `char` and `wchar_t` version. Parsing the format-spec and using the parsed format-spec hasn't been implemented. The code isn't optimized, neither for speed, nor for size. The goal is to have the rudimentary basics working, which can be used as a basis to improve upon. The formatters used in this commit are simple stubs that will be replaced by real formatters in later commits. The formatters that are slated to be replaced in this patch series don't have an availability macro to avoid merge conflicts. Note the formatter for `bool` uses `0` and `1` instead of "false" and "true". This will be fixed when the stub is replaced with a real formatter. Implements parts of: - P0645 Text Formatting Completes: - LWG3539 format_to must not copy models of output_iterator<const charT&> Reviewed By: ldionne, #libc, vitaut Differential Revision: https://reviews.llvm.org/D96664
2020-12-19 20:52:07 +08:00
return _VSTD::__vformat_to(_VSTD::move(__out_it), _VSTD::move(__loc), __fmt,
__args);
}
[libc++] Add an option to disable wide character support in libc++ 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. Differential Revision: https://reviews.llvm.org/D111265
2021-08-24 03:32:36 +08:00
#endif
[libc++][format] Implement formatters. This implements the initial version of the `std::formatter` class and its specializations. It also implements the following formatting functions: - `format` - `vformat` - `format_to` - `vformat_to` - `format_to_n` - `formatted_size` All functions have a `char` and `wchar_t` version. Parsing the format-spec and using the parsed format-spec hasn't been implemented. The code isn't optimized, neither for speed, nor for size. The goal is to have the rudimentary basics working, which can be used as a basis to improve upon. The formatters used in this commit are simple stubs that will be replaced by real formatters in later commits. The formatters that are slated to be replaced in this patch series don't have an availability macro to avoid merge conflicts. Note the formatter for `bool` uses `0` and `1` instead of "false" and "true". This will be fixed when the stub is replaced with a real formatter. Implements parts of: - P0645 Text Formatting Completes: - LWG3539 format_to must not copy models of output_iterator<const charT&> Reviewed By: ldionne, #libc, vitaut Differential Revision: https://reviews.llvm.org/D96664
2020-12-19 20:52:07 +08:00
template <output_iterator<const char&> _OutIt, class... _Args>
[libc++][format] Implement format-string. Implements the compile-time checking of the formatting arguments. Completes: - P2216 std::format improvements Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D121530
2021-10-02 18:38:46 +08:00
_LIBCPP_ALWAYS_INLINE _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT _OutIt
[libc++][format] Use forwarding references. This implements a not accepted LWG issue. Not doing so would require integral types to use the handle class instead of being directly stored in the basic_format_arg. The previous code used `std::forward` in places where it wasn't required by the Standard. These are now removed. Implements: - P2418R2 Add support for std::generator-like types to std::format - LWG 3631 basic_format_arg(T&&) should use remove_cvref_t<T> throughout Reviewed By: ldionne, #libc Differential Revision: https://reviews.llvm.org/D127570
2021-10-06 01:25:37 +08:00
format_to(_OutIt __out_it, locale __loc, __format_string_t<_Args...> __fmt, _Args&&... __args) {
[libc++][format] Implement format-string. Implements the compile-time checking of the formatting arguments. Completes: - P2216 std::format improvements Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D121530
2021-10-02 18:38:46 +08:00
return _VSTD::vformat_to(_VSTD::move(__out_it), _VSTD::move(__loc), __fmt.__str_,
[libc++][format][1/6] Reduce binary size. This removes the `format_args_t` from `<format>` and adjusts the type of the `format_args` for the `vformat_to` overloads. The `format_context` uses a `back_insert_iterator<string>` therefore the new `output_iterator` function uses a `string` as its temporary storage buffer. This isn't ideal. The next patches in this series will improve this. These improvements make it easy to also improve `format_to_n` and `formatted_size`. This addresses P2216 `6. Binary size`. P2216 `5. Compile-time checks` are not part of this change. Implements parts of: - P2216 std::format improvements Depends on D103670 Reviewed By: ldionne, #libc Differential Revision: https://reviews.llvm.org/D110494
2021-09-04 19:26:58 +08:00
_VSTD::make_format_args(__args...));
[libc++][format] Implement formatters. This implements the initial version of the `std::formatter` class and its specializations. It also implements the following formatting functions: - `format` - `vformat` - `format_to` - `vformat_to` - `format_to_n` - `formatted_size` All functions have a `char` and `wchar_t` version. Parsing the format-spec and using the parsed format-spec hasn't been implemented. The code isn't optimized, neither for speed, nor for size. The goal is to have the rudimentary basics working, which can be used as a basis to improve upon. The formatters used in this commit are simple stubs that will be replaced by real formatters in later commits. The formatters that are slated to be replaced in this patch series don't have an availability macro to avoid merge conflicts. Note the formatter for `bool` uses `0` and `1` instead of "false" and "true". This will be fixed when the stub is replaced with a real formatter. Implements parts of: - P0645 Text Formatting Completes: - LWG3539 format_to must not copy models of output_iterator<const charT&> Reviewed By: ldionne, #libc, vitaut Differential Revision: https://reviews.llvm.org/D96664
2020-12-19 20:52:07 +08:00
}
[libc++] Add an option to disable wide character support in libc++ 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. Differential Revision: https://reviews.llvm.org/D111265
2021-08-24 03:32:36 +08:00
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
[libc++][format] Implement formatters. This implements the initial version of the `std::formatter` class and its specializations. It also implements the following formatting functions: - `format` - `vformat` - `format_to` - `vformat_to` - `format_to_n` - `formatted_size` All functions have a `char` and `wchar_t` version. Parsing the format-spec and using the parsed format-spec hasn't been implemented. The code isn't optimized, neither for speed, nor for size. The goal is to have the rudimentary basics working, which can be used as a basis to improve upon. The formatters used in this commit are simple stubs that will be replaced by real formatters in later commits. The formatters that are slated to be replaced in this patch series don't have an availability macro to avoid merge conflicts. Note the formatter for `bool` uses `0` and `1` instead of "false" and "true". This will be fixed when the stub is replaced with a real formatter. Implements parts of: - P0645 Text Formatting Completes: - LWG3539 format_to must not copy models of output_iterator<const charT&> Reviewed By: ldionne, #libc, vitaut Differential Revision: https://reviews.llvm.org/D96664
2020-12-19 20:52:07 +08:00
template <output_iterator<const wchar_t&> _OutIt, class... _Args>
[libc++][format] Implement format-string. Implements the compile-time checking of the formatting arguments. Completes: - P2216 std::format improvements Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D121530
2021-10-02 18:38:46 +08:00
_LIBCPP_ALWAYS_INLINE _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT _OutIt
[libc++][format] Use forwarding references. This implements a not accepted LWG issue. Not doing so would require integral types to use the handle class instead of being directly stored in the basic_format_arg. The previous code used `std::forward` in places where it wasn't required by the Standard. These are now removed. Implements: - P2418R2 Add support for std::generator-like types to std::format - LWG 3631 basic_format_arg(T&&) should use remove_cvref_t<T> throughout Reviewed By: ldionne, #libc Differential Revision: https://reviews.llvm.org/D127570
2021-10-06 01:25:37 +08:00
format_to(_OutIt __out_it, locale __loc, __wformat_string_t<_Args...> __fmt, _Args&&... __args) {
[libc++][format] Implement format-string. Implements the compile-time checking of the formatting arguments. Completes: - P2216 std::format improvements Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D121530
2021-10-02 18:38:46 +08:00
return _VSTD::vformat_to(_VSTD::move(__out_it), _VSTD::move(__loc), __fmt.__str_,
[libc++][format][1/6] Reduce binary size. This removes the `format_args_t` from `<format>` and adjusts the type of the `format_args` for the `vformat_to` overloads. The `format_context` uses a `back_insert_iterator<string>` therefore the new `output_iterator` function uses a `string` as its temporary storage buffer. This isn't ideal. The next patches in this series will improve this. These improvements make it easy to also improve `format_to_n` and `formatted_size`. This addresses P2216 `6. Binary size`. P2216 `5. Compile-time checks` are not part of this change. Implements parts of: - P2216 std::format improvements Depends on D103670 Reviewed By: ldionne, #libc Differential Revision: https://reviews.llvm.org/D110494
2021-09-04 19:26:58 +08:00
_VSTD::make_wformat_args(__args...));
[libc++][format] Implement formatters. This implements the initial version of the `std::formatter` class and its specializations. It also implements the following formatting functions: - `format` - `vformat` - `format_to` - `vformat_to` - `format_to_n` - `formatted_size` All functions have a `char` and `wchar_t` version. Parsing the format-spec and using the parsed format-spec hasn't been implemented. The code isn't optimized, neither for speed, nor for size. The goal is to have the rudimentary basics working, which can be used as a basis to improve upon. The formatters used in this commit are simple stubs that will be replaced by real formatters in later commits. The formatters that are slated to be replaced in this patch series don't have an availability macro to avoid merge conflicts. Note the formatter for `bool` uses `0` and `1` instead of "false" and "true". This will be fixed when the stub is replaced with a real formatter. Implements parts of: - P0645 Text Formatting Completes: - LWG3539 format_to must not copy models of output_iterator<const charT&> Reviewed By: ldionne, #libc, vitaut Differential Revision: https://reviews.llvm.org/D96664
2020-12-19 20:52:07 +08:00
}
[libc++] Add an option to disable wide character support in libc++ 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. Differential Revision: https://reviews.llvm.org/D111265
2021-08-24 03:32:36 +08:00
#endif
[libc++][format] Implement formatters. This implements the initial version of the `std::formatter` class and its specializations. It also implements the following formatting functions: - `format` - `vformat` - `format_to` - `vformat_to` - `format_to_n` - `formatted_size` All functions have a `char` and `wchar_t` version. Parsing the format-spec and using the parsed format-spec hasn't been implemented. The code isn't optimized, neither for speed, nor for size. The goal is to have the rudimentary basics working, which can be used as a basis to improve upon. The formatters used in this commit are simple stubs that will be replaced by real formatters in later commits. The formatters that are slated to be replaced in this patch series don't have an availability macro to avoid merge conflicts. Note the formatter for `bool` uses `0` and `1` instead of "false" and "true". This will be fixed when the stub is replaced with a real formatter. Implements parts of: - P0645 Text Formatting Completes: - LWG3539 format_to must not copy models of output_iterator<const charT&> Reviewed By: ldionne, #libc, vitaut Differential Revision: https://reviews.llvm.org/D96664
2020-12-19 20:52:07 +08:00
[libc++][format][1/6] Reduce binary size. This removes the `format_args_t` from `<format>` and adjusts the type of the `format_args` for the `vformat_to` overloads. The `format_context` uses a `back_insert_iterator<string>` therefore the new `output_iterator` function uses a `string` as its temporary storage buffer. This isn't ideal. The next patches in this series will improve this. These improvements make it easy to also improve `format_to_n` and `formatted_size`. This addresses P2216 `6. Binary size`. P2216 `5. Compile-time checks` are not part of this change. Implements parts of: - P2216 std::format improvements Depends on D103670 Reviewed By: ldionne, #libc Differential Revision: https://reviews.llvm.org/D110494
2021-09-04 19:26:58 +08:00
_LIBCPP_ALWAYS_INLINE inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT string
[libc++][format] Implement formatters. This implements the initial version of the `std::formatter` class and its specializations. It also implements the following formatting functions: - `format` - `vformat` - `format_to` - `vformat_to` - `format_to_n` - `formatted_size` All functions have a `char` and `wchar_t` version. Parsing the format-spec and using the parsed format-spec hasn't been implemented. The code isn't optimized, neither for speed, nor for size. The goal is to have the rudimentary basics working, which can be used as a basis to improve upon. The formatters used in this commit are simple stubs that will be replaced by real formatters in later commits. The formatters that are slated to be replaced in this patch series don't have an availability macro to avoid merge conflicts. Note the formatter for `bool` uses `0` and `1` instead of "false" and "true". This will be fixed when the stub is replaced with a real formatter. Implements parts of: - P0645 Text Formatting Completes: - LWG3539 format_to must not copy models of output_iterator<const charT&> Reviewed By: ldionne, #libc, vitaut Differential Revision: https://reviews.llvm.org/D96664
2020-12-19 20:52:07 +08:00
vformat(locale __loc, string_view __fmt, format_args __args) {
string __res;
_VSTD::vformat_to(_VSTD::back_inserter(__res), _VSTD::move(__loc), __fmt,
__args);
return __res;
}
[libc++] Add an option to disable wide character support in libc++ 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. Differential Revision: https://reviews.llvm.org/D111265
2021-08-24 03:32:36 +08:00
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
[libc++][format][1/6] Reduce binary size. This removes the `format_args_t` from `<format>` and adjusts the type of the `format_args` for the `vformat_to` overloads. The `format_context` uses a `back_insert_iterator<string>` therefore the new `output_iterator` function uses a `string` as its temporary storage buffer. This isn't ideal. The next patches in this series will improve this. These improvements make it easy to also improve `format_to_n` and `formatted_size`. This addresses P2216 `6. Binary size`. P2216 `5. Compile-time checks` are not part of this change. Implements parts of: - P2216 std::format improvements Depends on D103670 Reviewed By: ldionne, #libc Differential Revision: https://reviews.llvm.org/D110494
2021-09-04 19:26:58 +08:00
_LIBCPP_ALWAYS_INLINE inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT wstring
[libc++][format] Implement formatters. This implements the initial version of the `std::formatter` class and its specializations. It also implements the following formatting functions: - `format` - `vformat` - `format_to` - `vformat_to` - `format_to_n` - `formatted_size` All functions have a `char` and `wchar_t` version. Parsing the format-spec and using the parsed format-spec hasn't been implemented. The code isn't optimized, neither for speed, nor for size. The goal is to have the rudimentary basics working, which can be used as a basis to improve upon. The formatters used in this commit are simple stubs that will be replaced by real formatters in later commits. The formatters that are slated to be replaced in this patch series don't have an availability macro to avoid merge conflicts. Note the formatter for `bool` uses `0` and `1` instead of "false" and "true". This will be fixed when the stub is replaced with a real formatter. Implements parts of: - P0645 Text Formatting Completes: - LWG3539 format_to must not copy models of output_iterator<const charT&> Reviewed By: ldionne, #libc, vitaut Differential Revision: https://reviews.llvm.org/D96664
2020-12-19 20:52:07 +08:00
vformat(locale __loc, wstring_view __fmt, wformat_args __args) {
wstring __res;
_VSTD::vformat_to(_VSTD::back_inserter(__res), _VSTD::move(__loc), __fmt,
__args);
return __res;
}
[libc++] Add an option to disable wide character support in libc++ 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. Differential Revision: https://reviews.llvm.org/D111265
2021-08-24 03:32:36 +08:00
#endif
[libc++][format] Implement formatters. This implements the initial version of the `std::formatter` class and its specializations. It also implements the following formatting functions: - `format` - `vformat` - `format_to` - `vformat_to` - `format_to_n` - `formatted_size` All functions have a `char` and `wchar_t` version. Parsing the format-spec and using the parsed format-spec hasn't been implemented. The code isn't optimized, neither for speed, nor for size. The goal is to have the rudimentary basics working, which can be used as a basis to improve upon. The formatters used in this commit are simple stubs that will be replaced by real formatters in later commits. The formatters that are slated to be replaced in this patch series don't have an availability macro to avoid merge conflicts. Note the formatter for `bool` uses `0` and `1` instead of "false" and "true". This will be fixed when the stub is replaced with a real formatter. Implements parts of: - P0645 Text Formatting Completes: - LWG3539 format_to must not copy models of output_iterator<const charT&> Reviewed By: ldionne, #libc, vitaut Differential Revision: https://reviews.llvm.org/D96664
2020-12-19 20:52:07 +08:00
template <class... _Args>
[libc++][format] Implement format-string. Implements the compile-time checking of the formatting arguments. Completes: - P2216 std::format improvements Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D121530
2021-10-02 18:38:46 +08:00
_LIBCPP_ALWAYS_INLINE _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT string format(locale __loc,
__format_string_t<_Args...> __fmt,
[libc++][format] Use forwarding references. This implements a not accepted LWG issue. Not doing so would require integral types to use the handle class instead of being directly stored in the basic_format_arg. The previous code used `std::forward` in places where it wasn't required by the Standard. These are now removed. Implements: - P2418R2 Add support for std::generator-like types to std::format - LWG 3631 basic_format_arg(T&&) should use remove_cvref_t<T> throughout Reviewed By: ldionne, #libc Differential Revision: https://reviews.llvm.org/D127570
2021-10-06 01:25:37 +08:00
_Args&&... __args) {
[libc++][format] Implement format-string. Implements the compile-time checking of the formatting arguments. Completes: - P2216 std::format improvements Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D121530
2021-10-02 18:38:46 +08:00
return _VSTD::vformat(_VSTD::move(__loc), __fmt.__str_,
[libc++][format] Implement formatters. This implements the initial version of the `std::formatter` class and its specializations. It also implements the following formatting functions: - `format` - `vformat` - `format_to` - `vformat_to` - `format_to_n` - `formatted_size` All functions have a `char` and `wchar_t` version. Parsing the format-spec and using the parsed format-spec hasn't been implemented. The code isn't optimized, neither for speed, nor for size. The goal is to have the rudimentary basics working, which can be used as a basis to improve upon. The formatters used in this commit are simple stubs that will be replaced by real formatters in later commits. The formatters that are slated to be replaced in this patch series don't have an availability macro to avoid merge conflicts. Note the formatter for `bool` uses `0` and `1` instead of "false" and "true". This will be fixed when the stub is replaced with a real formatter. Implements parts of: - P0645 Text Formatting Completes: - LWG3539 format_to must not copy models of output_iterator<const charT&> Reviewed By: ldionne, #libc, vitaut Differential Revision: https://reviews.llvm.org/D96664
2020-12-19 20:52:07 +08:00
_VSTD::make_format_args(__args...));
}
[libc++] Add an option to disable wide character support in libc++ 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. Differential Revision: https://reviews.llvm.org/D111265
2021-08-24 03:32:36 +08:00
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
[libc++][format] Implement formatters. This implements the initial version of the `std::formatter` class and its specializations. It also implements the following formatting functions: - `format` - `vformat` - `format_to` - `vformat_to` - `format_to_n` - `formatted_size` All functions have a `char` and `wchar_t` version. Parsing the format-spec and using the parsed format-spec hasn't been implemented. The code isn't optimized, neither for speed, nor for size. The goal is to have the rudimentary basics working, which can be used as a basis to improve upon. The formatters used in this commit are simple stubs that will be replaced by real formatters in later commits. The formatters that are slated to be replaced in this patch series don't have an availability macro to avoid merge conflicts. Note the formatter for `bool` uses `0` and `1` instead of "false" and "true". This will be fixed when the stub is replaced with a real formatter. Implements parts of: - P0645 Text Formatting Completes: - LWG3539 format_to must not copy models of output_iterator<const charT&> Reviewed By: ldionne, #libc, vitaut Differential Revision: https://reviews.llvm.org/D96664
2020-12-19 20:52:07 +08:00
template <class... _Args>
[libc++][format][1/6] Reduce binary size. This removes the `format_args_t` from `<format>` and adjusts the type of the `format_args` for the `vformat_to` overloads. The `format_context` uses a `back_insert_iterator<string>` therefore the new `output_iterator` function uses a `string` as its temporary storage buffer. This isn't ideal. The next patches in this series will improve this. These improvements make it easy to also improve `format_to_n` and `formatted_size`. This addresses P2216 `6. Binary size`. P2216 `5. Compile-time checks` are not part of this change. Implements parts of: - P2216 std::format improvements Depends on D103670 Reviewed By: ldionne, #libc Differential Revision: https://reviews.llvm.org/D110494
2021-09-04 19:26:58 +08:00
_LIBCPP_ALWAYS_INLINE _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT wstring
[libc++][format] Use forwarding references. This implements a not accepted LWG issue. Not doing so would require integral types to use the handle class instead of being directly stored in the basic_format_arg. The previous code used `std::forward` in places where it wasn't required by the Standard. These are now removed. Implements: - P2418R2 Add support for std::generator-like types to std::format - LWG 3631 basic_format_arg(T&&) should use remove_cvref_t<T> throughout Reviewed By: ldionne, #libc Differential Revision: https://reviews.llvm.org/D127570
2021-10-06 01:25:37 +08:00
format(locale __loc, __wformat_string_t<_Args...> __fmt, _Args&&... __args) {
[libc++][format] Implement format-string. Implements the compile-time checking of the formatting arguments. Completes: - P2216 std::format improvements Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D121530
2021-10-02 18:38:46 +08:00
return _VSTD::vformat(_VSTD::move(__loc), __fmt.__str_,
[libc++][format] Implement formatters. This implements the initial version of the `std::formatter` class and its specializations. It also implements the following formatting functions: - `format` - `vformat` - `format_to` - `vformat_to` - `format_to_n` - `formatted_size` All functions have a `char` and `wchar_t` version. Parsing the format-spec and using the parsed format-spec hasn't been implemented. The code isn't optimized, neither for speed, nor for size. The goal is to have the rudimentary basics working, which can be used as a basis to improve upon. The formatters used in this commit are simple stubs that will be replaced by real formatters in later commits. The formatters that are slated to be replaced in this patch series don't have an availability macro to avoid merge conflicts. Note the formatter for `bool` uses `0` and `1` instead of "false" and "true". This will be fixed when the stub is replaced with a real formatter. Implements parts of: - P0645 Text Formatting Completes: - LWG3539 format_to must not copy models of output_iterator<const charT&> Reviewed By: ldionne, #libc, vitaut Differential Revision: https://reviews.llvm.org/D96664
2020-12-19 20:52:07 +08:00
_VSTD::make_wformat_args(__args...));
}
[libc++] Add an option to disable wide character support in libc++ 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. Differential Revision: https://reviews.llvm.org/D111265
2021-08-24 03:32:36 +08:00
#endif
[libc++][format] Implement formatters. This implements the initial version of the `std::formatter` class and its specializations. It also implements the following formatting functions: - `format` - `vformat` - `format_to` - `vformat_to` - `format_to_n` - `formatted_size` All functions have a `char` and `wchar_t` version. Parsing the format-spec and using the parsed format-spec hasn't been implemented. The code isn't optimized, neither for speed, nor for size. The goal is to have the rudimentary basics working, which can be used as a basis to improve upon. The formatters used in this commit are simple stubs that will be replaced by real formatters in later commits. The formatters that are slated to be replaced in this patch series don't have an availability macro to avoid merge conflicts. Note the formatter for `bool` uses `0` and `1` instead of "false" and "true". This will be fixed when the stub is replaced with a real formatter. Implements parts of: - P0645 Text Formatting Completes: - LWG3539 format_to must not copy models of output_iterator<const charT&> Reviewed By: ldionne, #libc, vitaut Differential Revision: https://reviews.llvm.org/D96664
2020-12-19 20:52:07 +08:00
[libc++][format][5/6] Improve format_to_n. Use a specialized buffer wrapper to limit the number of insertions in the buffer. After the limit has been reached the buffer only needs to count the number of insertions to return the buffer size required to store the entire output. Depends on D110498 Reviewed By: #libc, Mordante Differential Revision: https://reviews.llvm.org/D110499
2021-09-26 23:04:53 +08:00
template <class _Context, class _OutIt, class _CharT>
_LIBCPP_HIDE_FROM_ABI format_to_n_result<_OutIt> __vformat_to_n(_OutIt __out_it, iter_difference_t<_OutIt> __n,
locale __loc, basic_string_view<_CharT> __fmt,
basic_format_args<_Context> __args) {
__format::__format_to_n_buffer<_OutIt, _CharT> __buffer{_VSTD::move(__out_it), __n};
_VSTD::__format::__vformat_to(
basic_format_parse_context{__fmt, __args.__size()},
_VSTD::__format_context_create(__buffer.make_output_iterator(), __args, _VSTD::move(__loc)));
return _VSTD::move(__buffer).result();
}
[libc++][format] Implement formatters. This implements the initial version of the `std::formatter` class and its specializations. It also implements the following formatting functions: - `format` - `vformat` - `format_to` - `vformat_to` - `format_to_n` - `formatted_size` All functions have a `char` and `wchar_t` version. Parsing the format-spec and using the parsed format-spec hasn't been implemented. The code isn't optimized, neither for speed, nor for size. The goal is to have the rudimentary basics working, which can be used as a basis to improve upon. The formatters used in this commit are simple stubs that will be replaced by real formatters in later commits. The formatters that are slated to be replaced in this patch series don't have an availability macro to avoid merge conflicts. Note the formatter for `bool` uses `0` and `1` instead of "false" and "true". This will be fixed when the stub is replaced with a real formatter. Implements parts of: - P0645 Text Formatting Completes: - LWG3539 format_to must not copy models of output_iterator<const charT&> Reviewed By: ldionne, #libc, vitaut Differential Revision: https://reviews.llvm.org/D96664
2020-12-19 20:52:07 +08:00
template <output_iterator<const char&> _OutIt, class... _Args>
[libc++][format][5/6] Improve format_to_n. Use a specialized buffer wrapper to limit the number of insertions in the buffer. After the limit has been reached the buffer only needs to count the number of insertions to return the buffer size required to store the entire output. Depends on D110498 Reviewed By: #libc, Mordante Differential Revision: https://reviews.llvm.org/D110499
2021-09-26 23:04:53 +08:00
_LIBCPP_ALWAYS_INLINE _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT format_to_n_result<_OutIt>
[libc++][format] Implement format-string. Implements the compile-time checking of the formatting arguments. Completes: - P2216 std::format improvements Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D121530
2021-10-02 18:38:46 +08:00
format_to_n(_OutIt __out_it, iter_difference_t<_OutIt> __n, locale __loc, __format_string_t<_Args...> __fmt,
[libc++][format] Use forwarding references. This implements a not accepted LWG issue. Not doing so would require integral types to use the handle class instead of being directly stored in the basic_format_arg. The previous code used `std::forward` in places where it wasn't required by the Standard. These are now removed. Implements: - P2418R2 Add support for std::generator-like types to std::format - LWG 3631 basic_format_arg(T&&) should use remove_cvref_t<T> throughout Reviewed By: ldionne, #libc Differential Revision: https://reviews.llvm.org/D127570
2021-10-06 01:25:37 +08:00
_Args&&... __args) {
[libc++][format] Implement format-string. Implements the compile-time checking of the formatting arguments. Completes: - P2216 std::format improvements Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D121530
2021-10-02 18:38:46 +08:00
return _VSTD::__vformat_to_n<format_context>(_VSTD::move(__out_it), __n, _VSTD::move(__loc), __fmt.__str_,
[libc++][format][5/6] Improve format_to_n. Use a specialized buffer wrapper to limit the number of insertions in the buffer. After the limit has been reached the buffer only needs to count the number of insertions to return the buffer size required to store the entire output. Depends on D110498 Reviewed By: #libc, Mordante Differential Revision: https://reviews.llvm.org/D110499
2021-09-26 23:04:53 +08:00
_VSTD::make_format_args(__args...));
[libc++][format] Implement formatters. This implements the initial version of the `std::formatter` class and its specializations. It also implements the following formatting functions: - `format` - `vformat` - `format_to` - `vformat_to` - `format_to_n` - `formatted_size` All functions have a `char` and `wchar_t` version. Parsing the format-spec and using the parsed format-spec hasn't been implemented. The code isn't optimized, neither for speed, nor for size. The goal is to have the rudimentary basics working, which can be used as a basis to improve upon. The formatters used in this commit are simple stubs that will be replaced by real formatters in later commits. The formatters that are slated to be replaced in this patch series don't have an availability macro to avoid merge conflicts. Note the formatter for `bool` uses `0` and `1` instead of "false" and "true". This will be fixed when the stub is replaced with a real formatter. Implements parts of: - P0645 Text Formatting Completes: - LWG3539 format_to must not copy models of output_iterator<const charT&> Reviewed By: ldionne, #libc, vitaut Differential Revision: https://reviews.llvm.org/D96664
2020-12-19 20:52:07 +08:00
}
[libc++] Add an option to disable wide character support in libc++ 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. Differential Revision: https://reviews.llvm.org/D111265
2021-08-24 03:32:36 +08:00
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
[libc++][format] Implement formatters. This implements the initial version of the `std::formatter` class and its specializations. It also implements the following formatting functions: - `format` - `vformat` - `format_to` - `vformat_to` - `format_to_n` - `formatted_size` All functions have a `char` and `wchar_t` version. Parsing the format-spec and using the parsed format-spec hasn't been implemented. The code isn't optimized, neither for speed, nor for size. The goal is to have the rudimentary basics working, which can be used as a basis to improve upon. The formatters used in this commit are simple stubs that will be replaced by real formatters in later commits. The formatters that are slated to be replaced in this patch series don't have an availability macro to avoid merge conflicts. Note the formatter for `bool` uses `0` and `1` instead of "false" and "true". This will be fixed when the stub is replaced with a real formatter. Implements parts of: - P0645 Text Formatting Completes: - LWG3539 format_to must not copy models of output_iterator<const charT&> Reviewed By: ldionne, #libc, vitaut Differential Revision: https://reviews.llvm.org/D96664
2020-12-19 20:52:07 +08:00
template <output_iterator<const wchar_t&> _OutIt, class... _Args>
[libc++][format][5/6] Improve format_to_n. Use a specialized buffer wrapper to limit the number of insertions in the buffer. After the limit has been reached the buffer only needs to count the number of insertions to return the buffer size required to store the entire output. Depends on D110498 Reviewed By: #libc, Mordante Differential Revision: https://reviews.llvm.org/D110499
2021-09-26 23:04:53 +08:00
_LIBCPP_ALWAYS_INLINE _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT format_to_n_result<_OutIt>
[libc++][format] Implement format-string. Implements the compile-time checking of the formatting arguments. Completes: - P2216 std::format improvements Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D121530
2021-10-02 18:38:46 +08:00
format_to_n(_OutIt __out_it, iter_difference_t<_OutIt> __n, locale __loc, __wformat_string_t<_Args...> __fmt,
[libc++][format] Use forwarding references. This implements a not accepted LWG issue. Not doing so would require integral types to use the handle class instead of being directly stored in the basic_format_arg. The previous code used `std::forward` in places where it wasn't required by the Standard. These are now removed. Implements: - P2418R2 Add support for std::generator-like types to std::format - LWG 3631 basic_format_arg(T&&) should use remove_cvref_t<T> throughout Reviewed By: ldionne, #libc Differential Revision: https://reviews.llvm.org/D127570
2021-10-06 01:25:37 +08:00
_Args&&... __args) {
[libc++][format] Implement format-string. Implements the compile-time checking of the formatting arguments. Completes: - P2216 std::format improvements Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D121530
2021-10-02 18:38:46 +08:00
return _VSTD::__vformat_to_n<wformat_context>(_VSTD::move(__out_it), __n, _VSTD::move(__loc), __fmt.__str_,
[libc++][format][5/6] Improve format_to_n. Use a specialized buffer wrapper to limit the number of insertions in the buffer. After the limit has been reached the buffer only needs to count the number of insertions to return the buffer size required to store the entire output. Depends on D110498 Reviewed By: #libc, Mordante Differential Revision: https://reviews.llvm.org/D110499
2021-09-26 23:04:53 +08:00
_VSTD::make_wformat_args(__args...));
[libc++][format] Implement formatters. This implements the initial version of the `std::formatter` class and its specializations. It also implements the following formatting functions: - `format` - `vformat` - `format_to` - `vformat_to` - `format_to_n` - `formatted_size` All functions have a `char` and `wchar_t` version. Parsing the format-spec and using the parsed format-spec hasn't been implemented. The code isn't optimized, neither for speed, nor for size. The goal is to have the rudimentary basics working, which can be used as a basis to improve upon. The formatters used in this commit are simple stubs that will be replaced by real formatters in later commits. The formatters that are slated to be replaced in this patch series don't have an availability macro to avoid merge conflicts. Note the formatter for `bool` uses `0` and `1` instead of "false" and "true". This will be fixed when the stub is replaced with a real formatter. Implements parts of: - P0645 Text Formatting Completes: - LWG3539 format_to must not copy models of output_iterator<const charT&> Reviewed By: ldionne, #libc, vitaut Differential Revision: https://reviews.llvm.org/D96664
2020-12-19 20:52:07 +08:00
}
[libc++] Add an option to disable wide character support in libc++ 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. Differential Revision: https://reviews.llvm.org/D111265
2021-08-24 03:32:36 +08:00
#endif
[libc++][format] Implement formatters. This implements the initial version of the `std::formatter` class and its specializations. It also implements the following formatting functions: - `format` - `vformat` - `format_to` - `vformat_to` - `format_to_n` - `formatted_size` All functions have a `char` and `wchar_t` version. Parsing the format-spec and using the parsed format-spec hasn't been implemented. The code isn't optimized, neither for speed, nor for size. The goal is to have the rudimentary basics working, which can be used as a basis to improve upon. The formatters used in this commit are simple stubs that will be replaced by real formatters in later commits. The formatters that are slated to be replaced in this patch series don't have an availability macro to avoid merge conflicts. Note the formatter for `bool` uses `0` and `1` instead of "false" and "true". This will be fixed when the stub is replaced with a real formatter. Implements parts of: - P0645 Text Formatting Completes: - LWG3539 format_to must not copy models of output_iterator<const charT&> Reviewed By: ldionne, #libc, vitaut Differential Revision: https://reviews.llvm.org/D96664
2020-12-19 20:52:07 +08:00
[libc++][format][4/6] Improve formatted_size. Use a specialized "buffer" to count the number of insertions instead of using a `string` as storage type. Depends on D110497. Reviewed By: ldionne, #libc Differential Revision: https://reviews.llvm.org/D110498
2021-09-26 22:48:25 +08:00
template <class _CharT>
_LIBCPP_HIDE_FROM_ABI size_t __vformatted_size(locale __loc, basic_string_view<_CharT> __fmt, auto __args) {
__format::__formatted_size_buffer<_CharT> __buffer;
_VSTD::__format::__vformat_to(
basic_format_parse_context{__fmt, __args.__size()},
_VSTD::__format_context_create(__buffer.make_output_iterator(), __args, _VSTD::move(__loc)));
return _VSTD::move(__buffer).result();
}
[libc++][format] Implement formatters. This implements the initial version of the `std::formatter` class and its specializations. It also implements the following formatting functions: - `format` - `vformat` - `format_to` - `vformat_to` - `format_to_n` - `formatted_size` All functions have a `char` and `wchar_t` version. Parsing the format-spec and using the parsed format-spec hasn't been implemented. The code isn't optimized, neither for speed, nor for size. The goal is to have the rudimentary basics working, which can be used as a basis to improve upon. The formatters used in this commit are simple stubs that will be replaced by real formatters in later commits. The formatters that are slated to be replaced in this patch series don't have an availability macro to avoid merge conflicts. Note the formatter for `bool` uses `0` and `1` instead of "false" and "true". This will be fixed when the stub is replaced with a real formatter. Implements parts of: - P0645 Text Formatting Completes: - LWG3539 format_to must not copy models of output_iterator<const charT&> Reviewed By: ldionne, #libc, vitaut Differential Revision: https://reviews.llvm.org/D96664
2020-12-19 20:52:07 +08:00
template <class... _Args>
[libc++][format] Implement format-string. Implements the compile-time checking of the formatting arguments. Completes: - P2216 std::format improvements Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D121530
2021-10-02 18:38:46 +08:00
_LIBCPP_ALWAYS_INLINE _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT size_t
[libc++][format] Use forwarding references. This implements a not accepted LWG issue. Not doing so would require integral types to use the handle class instead of being directly stored in the basic_format_arg. The previous code used `std::forward` in places where it wasn't required by the Standard. These are now removed. Implements: - P2418R2 Add support for std::generator-like types to std::format - LWG 3631 basic_format_arg(T&&) should use remove_cvref_t<T> throughout Reviewed By: ldionne, #libc Differential Revision: https://reviews.llvm.org/D127570
2021-10-06 01:25:37 +08:00
formatted_size(locale __loc, __format_string_t<_Args...> __fmt, _Args&&... __args) {
[libc++][format] Implement format-string. Implements the compile-time checking of the formatting arguments. Completes: - P2216 std::format improvements Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D121530
2021-10-02 18:38:46 +08:00
return _VSTD::__vformatted_size(_VSTD::move(__loc), __fmt.__str_, basic_format_args{_VSTD::make_format_args(__args...)});
[libc++][format] Implement formatters. This implements the initial version of the `std::formatter` class and its specializations. It also implements the following formatting functions: - `format` - `vformat` - `format_to` - `vformat_to` - `format_to_n` - `formatted_size` All functions have a `char` and `wchar_t` version. Parsing the format-spec and using the parsed format-spec hasn't been implemented. The code isn't optimized, neither for speed, nor for size. The goal is to have the rudimentary basics working, which can be used as a basis to improve upon. The formatters used in this commit are simple stubs that will be replaced by real formatters in later commits. The formatters that are slated to be replaced in this patch series don't have an availability macro to avoid merge conflicts. Note the formatter for `bool` uses `0` and `1` instead of "false" and "true". This will be fixed when the stub is replaced with a real formatter. Implements parts of: - P0645 Text Formatting Completes: - LWG3539 format_to must not copy models of output_iterator<const charT&> Reviewed By: ldionne, #libc, vitaut Differential Revision: https://reviews.llvm.org/D96664
2020-12-19 20:52:07 +08:00
}
[libc++] Add an option to disable wide character support in libc++ 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. Differential Revision: https://reviews.llvm.org/D111265
2021-08-24 03:32:36 +08:00
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
[libc++][format] Implement formatters. This implements the initial version of the `std::formatter` class and its specializations. It also implements the following formatting functions: - `format` - `vformat` - `format_to` - `vformat_to` - `format_to_n` - `formatted_size` All functions have a `char` and `wchar_t` version. Parsing the format-spec and using the parsed format-spec hasn't been implemented. The code isn't optimized, neither for speed, nor for size. The goal is to have the rudimentary basics working, which can be used as a basis to improve upon. The formatters used in this commit are simple stubs that will be replaced by real formatters in later commits. The formatters that are slated to be replaced in this patch series don't have an availability macro to avoid merge conflicts. Note the formatter for `bool` uses `0` and `1` instead of "false" and "true". This will be fixed when the stub is replaced with a real formatter. Implements parts of: - P0645 Text Formatting Completes: - LWG3539 format_to must not copy models of output_iterator<const charT&> Reviewed By: ldionne, #libc, vitaut Differential Revision: https://reviews.llvm.org/D96664
2020-12-19 20:52:07 +08:00
template <class... _Args>
[libc++][format] Implement format-string. Implements the compile-time checking of the formatting arguments. Completes: - P2216 std::format improvements Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D121530
2021-10-02 18:38:46 +08:00
_LIBCPP_ALWAYS_INLINE _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT size_t
[libc++][format] Use forwarding references. This implements a not accepted LWG issue. Not doing so would require integral types to use the handle class instead of being directly stored in the basic_format_arg. The previous code used `std::forward` in places where it wasn't required by the Standard. These are now removed. Implements: - P2418R2 Add support for std::generator-like types to std::format - LWG 3631 basic_format_arg(T&&) should use remove_cvref_t<T> throughout Reviewed By: ldionne, #libc Differential Revision: https://reviews.llvm.org/D127570
2021-10-06 01:25:37 +08:00
formatted_size(locale __loc, __wformat_string_t<_Args...> __fmt, _Args&&... __args) {
[libc++][format] Implement format-string. Implements the compile-time checking of the formatting arguments. Completes: - P2216 std::format improvements Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D121530
2021-10-02 18:38:46 +08:00
return _VSTD::__vformatted_size(_VSTD::move(__loc), __fmt.__str_, basic_format_args{_VSTD::make_wformat_args(__args...)});
[libc++][format] Implement formatters. This implements the initial version of the `std::formatter` class and its specializations. It also implements the following formatting functions: - `format` - `vformat` - `format_to` - `vformat_to` - `format_to_n` - `formatted_size` All functions have a `char` and `wchar_t` version. Parsing the format-spec and using the parsed format-spec hasn't been implemented. The code isn't optimized, neither for speed, nor for size. The goal is to have the rudimentary basics working, which can be used as a basis to improve upon. The formatters used in this commit are simple stubs that will be replaced by real formatters in later commits. The formatters that are slated to be replaced in this patch series don't have an availability macro to avoid merge conflicts. Note the formatter for `bool` uses `0` and `1` instead of "false" and "true". This will be fixed when the stub is replaced with a real formatter. Implements parts of: - P0645 Text Formatting Completes: - LWG3539 format_to must not copy models of output_iterator<const charT&> Reviewed By: ldionne, #libc, vitaut Differential Revision: https://reviews.llvm.org/D96664
2020-12-19 20:52:07 +08:00
}
[libc++] Add an option to disable wide character support in libc++ 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. Differential Revision: https://reviews.llvm.org/D111265
2021-08-24 03:32:36 +08:00
#endif
[libc++][format] Implement formatters. This implements the initial version of the `std::formatter` class and its specializations. It also implements the following formatting functions: - `format` - `vformat` - `format_to` - `vformat_to` - `format_to_n` - `formatted_size` All functions have a `char` and `wchar_t` version. Parsing the format-spec and using the parsed format-spec hasn't been implemented. The code isn't optimized, neither for speed, nor for size. The goal is to have the rudimentary basics working, which can be used as a basis to improve upon. The formatters used in this commit are simple stubs that will be replaced by real formatters in later commits. The formatters that are slated to be replaced in this patch series don't have an availability macro to avoid merge conflicts. Note the formatter for `bool` uses `0` and `1` instead of "false" and "true". This will be fixed when the stub is replaced with a real formatter. Implements parts of: - P0645 Text Formatting Completes: - LWG3539 format_to must not copy models of output_iterator<const charT&> Reviewed By: ldionne, #libc, vitaut Differential Revision: https://reviews.llvm.org/D96664
2020-12-19 20:52:07 +08:00
[libc++][NFC] Add #endif comment for long #if-#endif block
2021-09-10 02:43:02 +08:00
#endif // _LIBCPP_HAS_NO_LOCALIZATION
[libc++][format] Implement formatters. This implements the initial version of the `std::formatter` class and its specializations. It also implements the following formatting functions: - `format` - `vformat` - `format_to` - `vformat_to` - `format_to_n` - `formatted_size` All functions have a `char` and `wchar_t` version. Parsing the format-spec and using the parsed format-spec hasn't been implemented. The code isn't optimized, neither for speed, nor for size. The goal is to have the rudimentary basics working, which can be used as a basis to improve upon. The formatters used in this commit are simple stubs that will be replaced by real formatters in later commits. The formatters that are slated to be replaced in this patch series don't have an availability macro to avoid merge conflicts. Note the formatter for `bool` uses `0` and `1` instead of "false" and "true". This will be fixed when the stub is replaced with a real formatter. Implements parts of: - P0645 Text Formatting Completes: - LWG3539 format_to must not copy models of output_iterator<const charT&> Reviewed By: ldionne, #libc, vitaut Differential Revision: https://reviews.llvm.org/D96664
2020-12-19 20:52:07 +08:00
[libc++][format] Add __format_arg_store. This implements the struct `__format_arg_store` and its dependencies: * the class basic_format_arg, * the class basic_format_args, * the class basic_format_context, * the function make_format_args, * the function wmake_format_args, * the function visit_format_arg, * several Standard required typedefs. The following parts will be implemented in a later patch: * the child class `basic_format_arg::handle`, * the function `basic_format_arg::basic_format_arg(const T* p)`. The following extension has been implemented: * the class basic_format_arg supports `__[u]int128_t` on platform where libc++ supports 128 bit integrals. Implements parts of: * P0645 Text Formatting Completes: * LWG3371 visit_format_arg and make_format_args are not hidden friends * LWG3542 basic_format_arg mishandles basic_string_view with custom traits Note https://mordante.github.io/blog/2021/06/05/format.html gives a bit more information about the goals and non-goals of this initial patch series. Reviewed By: #libc, ldionne, vitaut Differential Revision: https://reviews.llvm.org/D103357
2020-12-05 18:45:21 +08:00
#endif //_LIBCPP_STD_VER > 17
_LIBCPP_END_NAMESPACE_STD
[libc++] Improve LIBCXX_ENABLE_INCOMPLETE_FEATURES. @tcanens pointed out the current behavior of the macro breaks the usage pattern described in http://wg21.link/SD6 ``` # if __has_include(<optional>) # include <optional> # if __cpp_lib_optional >= 201606 # define have_optional 1 # endif ``` To support this usage pattern the hard errror is removed. Instead the header includes nothing but the `<version>` header. Reviewed By: ldionne, #libc Differential Revision: https://reviews.llvm.org/D107134
2021-07-31 02:35:37 +08:00
#endif // !defined(_LIBCPP_HAS_NO_INCOMPLETE_FORMAT)
[libc++] Implement format_error. This is the first step at implementing <format>. It adds the <format> header and implements the `format_error`. class. Implemnts parts of: -P0645 Text Formatting Reviewed By: ldionne, #libc, miscco, curdeius Differential Revision: https://reviews.llvm.org/D92214
2020-11-27 02:12:18 +08:00
#endif // _LIBCPP_FORMAT