diff options
30 files changed, 6949 insertions, 6393 deletions
diff --git a/contrib/fmt/README.md b/contrib/fmt/README.md new file mode 100644 index 000000000..592ac2919 --- /dev/null +++ b/contrib/fmt/README.md @@ -0,0 +1,484 @@ +<img src="https://user-images.githubusercontent.com/576385/156254208-f5b743a9-88cf-439d-b0c0-923d53e8d551.png" alt="{fmt}" width="25%"/> + +[](https://github.com/fmtlib/fmt/actions?query=workflow%3Alinux) +[](https://github.com/fmtlib/fmt/actions?query=workflow%3Amacos) +[](https://github.com/fmtlib/fmt/actions?query=workflow%3Awindows) +[](https://bugs.chromium.org/p/oss-fuzz/issues/list?\%0Acolspec=ID%20Type%20Component%20Status%20Proj%20Reported%20Owner%20\%0ASummary&q=proj%3Dfmt&can=1) +[](https://stackoverflow.com/questions/tagged/fmt) +[](https://securityscorecards.dev/viewer/?uri=github.com/fmtlib/fmt) + +**{fmt}** is an open-source formatting library providing a fast and safe +alternative to C stdio and C++ iostreams. + +If you like this project, please consider donating to one of the funds +that help victims of the war in Ukraine: <https://www.stopputin.net/>. + +[Documentation](https://fmt.dev) + +[Cheat Sheets](https://hackingcpp.com/cpp/libs/fmt.html) + +Q&A: ask questions on [StackOverflow with the tag +fmt](https://stackoverflow.com/questions/tagged/fmt). + +Try {fmt} in [Compiler Explorer](https://godbolt.org/z/8Mx1EW73v). + +# Features + +- Simple [format API](https://fmt.dev/latest/api.html) with positional + arguments for localization +- Implementation of [C++20 + std::format](https://en.cppreference.com/w/cpp/utility/format) and + [C++23 std::print](https://en.cppreference.com/w/cpp/io/print) +- [Format string syntax](https://fmt.dev/latest/syntax.html) similar + to Python\'s + [format](https://docs.python.org/3/library/stdtypes.html#str.format) +- Fast IEEE 754 floating-point formatter with correct rounding, + shortness and round-trip guarantees using the + [Dragonbox](https://github.com/jk-jeon/dragonbox) algorithm +- Portable Unicode support +- Safe [printf + implementation](https://fmt.dev/latest/api.html#printf-formatting) + including the POSIX extension for positional arguments +- Extensibility: [support for user-defined + types](https://fmt.dev/latest/api.html#formatting-user-defined-types) +- High performance: faster than common standard library + implementations of `(s)printf`, iostreams, `to_string` and + `to_chars`, see [Speed tests](#speed-tests) and [Converting a + hundred million integers to strings per + second](http://www.zverovich.net/2020/06/13/fast-int-to-string-revisited.html) +- Small code size both in terms of source code with the minimum + configuration consisting of just three files, `core.h`, `format.h` + and `format-inl.h`, and compiled code; see [Compile time and code + bloat](#compile-time-and-code-bloat) +- Reliability: the library has an extensive set of + [tests](https://github.com/fmtlib/fmt/tree/master/test) and is + [continuously fuzzed](https://bugs.chromium.org/p/oss-fuzz/issues/list?colspec=ID%20Type%20Component%20Status%20Proj%20Reported%20Owner%20Summary&q=proj%3Dfmt&can=1) +- Safety: the library is fully type-safe, errors in format strings can + be reported at compile time, automatic memory management prevents + buffer overflow errors +- Ease of use: small self-contained code base, no external + dependencies, permissive MIT + [license](https://github.com/fmtlib/fmt/blob/master/LICENSE.rst) +- [Portability](https://fmt.dev/latest/index.html#portability) with + consistent output across platforms and support for older compilers +- Clean warning-free codebase even on high warning levels such as + `-Wall -Wextra -pedantic` +- Locale independence by default +- Optional header-only configuration enabled with the + `FMT_HEADER_ONLY` macro + +See the [documentation](https://fmt.dev) for more details. + +# Examples + +**Print to stdout** ([run](https://godbolt.org/z/Tevcjh)) + +``` c++ +#include <fmt/core.h> + +int main() { + fmt::print("Hello, world!\n"); +} +``` + +**Format a string** ([run](https://godbolt.org/z/oK8h33)) + +``` c++ +std::string s = fmt::format("The answer is {}.", 42); +// s == "The answer is 42." +``` + +**Format a string using positional arguments** +([run](https://godbolt.org/z/Yn7Txe)) + +``` c++ +std::string s = fmt::format("I'd rather be {1} than {0}.", "right", "happy"); +// s == "I'd rather be happy than right." +``` + +**Print dates and times** ([run](https://godbolt.org/z/c31ExdY3W)) + +``` c++ +#include <fmt/chrono.h> + +int main() { + auto now = std::chrono::system_clock::now(); + fmt::print("Date and time: {}\n", now); + fmt::print("Time: {:%H:%M}\n", now); +} +``` + +Output: + + Date and time: 2023-12-26 19:10:31.557195597 + Time: 19:10 + +**Print a container** ([run](https://godbolt.org/z/MxM1YqjE7)) + +``` c++ +#include <vector> +#include <fmt/ranges.h> + +int main() { + std::vector<int> v = {1, 2, 3}; + fmt::print("{}\n", v); +} +``` + +Output: + + [1, 2, 3] + +**Check a format string at compile time** + +``` c++ +std::string s = fmt::format("{:d}", "I am not a number"); +``` + +This gives a compile-time error in C++20 because `d` is an invalid +format specifier for a string. + +**Write a file from a single thread** + +``` c++ +#include <fmt/os.h> + +int main() { + auto out = fmt::output_file("guide.txt"); + out.print("Don't {}", "Panic"); +} +``` + +This can be [5 to 9 times faster than +fprintf](http://www.zverovich.net/2020/08/04/optimal-file-buffer-size.html). + +**Print with colors and text styles** + +``` c++ +#include <fmt/color.h> + +int main() { + fmt::print(fg(fmt::color::crimson) | fmt::emphasis::bold, + "Hello, {}!\n", "world"); + fmt::print(fg(fmt::color::floral_white) | bg(fmt::color::slate_gray) | + fmt::emphasis::underline, "Olá, {}!\n", "Mundo"); + fmt::print(fg(fmt::color::steel_blue) | fmt::emphasis::italic, + "你好{}！\n", "世界"); +} +``` + +Output on a modern terminal with Unicode support: + + + +# Benchmarks + +## Speed tests + +| Library | Method | Run Time, s | +|-------------------|---------------|-------------| +| libc | printf | 0.91 | +| libc++ | std::ostream | 2.49 | +| {fmt} 9.1 | fmt::print | 0.74 | +| Boost Format 1.80 | boost::format | 6.26 | +| Folly Format | folly::format | 1.87 | + +{fmt} is the fastest of the benchmarked methods, \~20% faster than +`printf`. + +The above results were generated by building `tinyformat_test.cpp` on +macOS 12.6.1 with `clang++ -O3 -DNDEBUG -DSPEED_TEST -DHAVE_FORMAT`, and +taking the best of three runs. In the test, the format string +`"%0.10f:%04d:%+g:%s:%p:%c:%%\n"` or equivalent is filled 2,000,000 +times with output sent to `/dev/null`; for further details refer to the +[source](https://github.com/fmtlib/format-benchmark/blob/master/src/tinyformat-test.cc). + +{fmt} is up to 20-30x faster than `std::ostringstream` and `sprintf` on +IEEE754 `float` and `double` formatting +([dtoa-benchmark](https://github.com/fmtlib/dtoa-benchmark)) and faster +than [double-conversion](https://github.com/google/double-conversion) +and [ryu](https://github.com/ulfjack/ryu): + +[](https://fmt.dev/unknown_mac64_clang12.0.html) + +## Compile time and code bloat + +The script [bloat-test.py][test] from [format-benchmark][bench] tests compile +time and code bloat for nontrivial projects. It generates 100 translation units +and uses `printf()` or its alternative five times in each to simulate a +medium-sized project. The resulting executable size and compile time (Apple +clang version 15.0.0 (clang-1500.1.0.2.5), macOS Sonoma, best of three) is shown +in the following tables. + +[test]: https://github.com/fmtlib/format-benchmark/blob/master/bloat-test.py +[bench]: https://github.com/fmtlib/format-benchmark + +**Optimized build (-O3)** + +| Method | Compile Time, s | Executable size, KiB | Stripped size, KiB | +|---------------|-----------------|----------------------|--------------------| +| printf | 1.6 | 54 | 50 | +| IOStreams | 25.9 | 98 | 84 | +| fmt 83652df | 4.8 | 54 | 50 | +| tinyformat | 29.1 | 161 | 136 | +| Boost Format | 55.0 | 530 | 317 | + +{fmt} is fast to compile and is comparable to `printf` in terms of per-call +binary size (within a rounding error on this system). + +**Non-optimized build** + +| Method | Compile Time, s | Executable size, KiB | Stripped size, KiB | +|---------------|-----------------|----------------------|--------------------| +| printf | 1.4 | 54 | 50 | +| IOStreams | 23.4 | 92 | 68 | +| {fmt} 83652df | 4.4 | 89 | 85 | +| tinyformat | 24.5 | 204 | 161 | +| Boost Format | 36.4 | 831 | 462 | + +`libc`, `lib(std)c++`, and `libfmt` are all linked as shared libraries +to compare formatting function overhead only. Boost Format is a +header-only library so it doesn\'t provide any linkage options. + +## Running the tests + +Please refer to [Building the +library](https://fmt.dev/latest/usage.html#building-the-library) for +instructions on how to build the library and run the unit tests. + +Benchmarks reside in a separate repository, +[format-benchmarks](https://github.com/fmtlib/format-benchmark), so to +run the benchmarks you first need to clone this repository and generate +Makefiles with CMake: + + $ git clone --recursive https://github.com/fmtlib/format-benchmark.git + $ cd format-benchmark + $ cmake . + +Then you can run the speed test: + + $ make speed-test + +or the bloat test: + + $ make bloat-test + +# Migrating code + +[clang-tidy](https://clang.llvm.org/extra/clang-tidy/) v18 provides the +[modernize-use-std-print](https://clang.llvm.org/extra/clang-tidy/checks/modernize/use-std-print.html) +check that is capable of converting occurrences of `printf` and +`fprintf` to `fmt::print` if configured to do so. (By default it +converts to `std::print`.) + +# Notable projects using this library + +- [0 A.D.](https://play0ad.com/): a free, open-source, cross-platform + real-time strategy game +- [AMPL/MP](https://github.com/ampl/mp): an open-source library for + mathematical programming +- [Apple's FoundationDB](https://github.com/apple/foundationdb): an open-source, + distributed, transactional key-value store +- [Aseprite](https://github.com/aseprite/aseprite): animated sprite + editor & pixel art tool +- [AvioBook](https://www.aviobook.aero/en): a comprehensive aircraft + operations suite +- [Blizzard Battle.net](https://battle.net/): an online gaming + platform +- [Celestia](https://celestia.space/): real-time 3D visualization of + space +- [Ceph](https://ceph.com/): a scalable distributed storage system +- [ccache](https://ccache.dev/): a compiler cache +- [ClickHouse](https://github.com/ClickHouse/ClickHouse): an + analytical database management system +- [Contour](https://github.com/contour-terminal/contour/): a modern + terminal emulator +- [CUAUV](https://cuauv.org/): Cornell University\'s autonomous + underwater vehicle +- [Drake](https://drake.mit.edu/): a planning, control, and analysis + toolbox for nonlinear dynamical systems (MIT) +- [Envoy](https://lyft.github.io/envoy/): C++ L7 proxy and + communication bus (Lyft) +- [FiveM](https://fivem.net/): a modification framework for GTA V +- [fmtlog](https://github.com/MengRao/fmtlog): a performant + fmtlib-style logging library with latency in nanoseconds +- [Folly](https://github.com/facebook/folly): Facebook open-source + library +- [GemRB](https://gemrb.org/): a portable open-source implementation + of Bioware's Infinity Engine +- [Grand Mountain + Adventure](https://store.steampowered.com/app/1247360/Grand_Mountain_Adventure/): + a beautiful open-world ski & snowboarding game +- [HarpyWar/pvpgn](https://github.com/pvpgn/pvpgn-server): Player vs + Player Gaming Network with tweaks +- [KBEngine](https://github.com/kbengine/kbengine): an open-source + MMOG server engine +- [Keypirinha](https://keypirinha.com/): a semantic launcher for + Windows +- [Kodi](https://kodi.tv/) (formerly xbmc): home theater software +- [Knuth](https://kth.cash/): high-performance Bitcoin full-node +- [libunicode](https://github.com/contour-terminal/libunicode/): a + modern C++17 Unicode library +- [MariaDB](https://mariadb.org/): relational database management + system +- [Microsoft Verona](https://github.com/microsoft/verona): research + programming language for concurrent ownership +- [MongoDB](https://mongodb.com/): distributed document database +- [MongoDB Smasher](https://github.com/duckie/mongo_smasher): a small + tool to generate randomized datasets +- [OpenSpace](https://openspaceproject.com/): an open-source + astrovisualization framework +- [PenUltima Online (POL)](https://www.polserver.com/): an MMO server, + compatible with most Ultima Online clients +- [PyTorch](https://github.com/pytorch/pytorch): an open-source + machine learning library +- [quasardb](https://www.quasardb.net/): a distributed, + high-performance, associative database +- [Quill](https://github.com/odygrd/quill): asynchronous low-latency + logging library +- [QKW](https://github.com/ravijanjam/qkw): generalizing aliasing to + simplify navigation, and execute complex multi-line terminal + command sequences +- [redis-cerberus](https://github.com/HunanTV/redis-cerberus): a Redis + cluster proxy +- [redpanda](https://vectorized.io/redpanda): a 10x faster Kafka® + replacement for mission-critical systems written in C++ +- [rpclib](http://rpclib.net/): a modern C++ msgpack-RPC server and + client library +- [Salesforce Analytics + Cloud](https://www.salesforce.com/analytics-cloud/overview/): + business intelligence software +- [Scylla](https://www.scylladb.com/): a Cassandra-compatible NoSQL + data store that can handle 1 million transactions per second on a + single server +- [Seastar](http://www.seastar-project.org/): an advanced, open-source + C++ framework for high-performance server applications on modern + hardware +- [spdlog](https://github.com/gabime/spdlog): super fast C++ logging + library +- [Stellar](https://www.stellar.org/): financial platform +- [Touch Surgery](https://www.touchsurgery.com/): surgery simulator +- [TrinityCore](https://github.com/TrinityCore/TrinityCore): + open-source MMORPG framework +- [🐙 userver framework](https://userver.tech/): open-source + asynchronous framework with a rich set of abstractions and database + drivers +- [Windows Terminal](https://github.com/microsoft/terminal): the new + Windows terminal + +[More\...](https://github.com/search?q=fmtlib&type=Code) + +If you are aware of other projects using this library, please let me +know by [email](mailto:victor.zverovich@gmail.com) or by submitting an +[issue](https://github.com/fmtlib/fmt/issues). + +# Motivation + +So why yet another formatting library? + +There are plenty of methods for doing this task, from standard ones like +the printf family of function and iostreams to Boost Format and +FastFormat libraries. The reason for creating a new library is that +every existing solution that I found either had serious issues or +didn\'t provide all the features I needed. + +## printf + +The good thing about `printf` is that it is pretty fast and readily +available being a part of the C standard library. The main drawback is +that it doesn\'t support user-defined types. `printf` also has safety +issues although they are somewhat mitigated with [\_\_attribute\_\_ +((format (printf, +\...))](https://gcc.gnu.org/onlinedocs/gcc/Function-Attributes.html) in +GCC. There is a POSIX extension that adds positional arguments required +for +[i18n](https://en.wikipedia.org/wiki/Internationalization_and_localization) +to `printf` but it is not a part of C99 and may not be available on some +platforms. + +## iostreams + +The main issue with iostreams is best illustrated with an example: + +``` c++ +std::cout << std::setprecision(2) << std::fixed << 1.23456 << "\n"; +``` + +which is a lot of typing compared to printf: + +``` c++ +printf("%.2f\n", 1.23456); +``` + +Matthew Wilson, the author of FastFormat, called this \"chevron hell\". +iostreams don\'t support positional arguments by design. + +The good part is that iostreams support user-defined types and are safe +although error handling is awkward. + +## Boost Format + +This is a very powerful library that supports both `printf`-like format +strings and positional arguments. Its main drawback is performance. +According to various benchmarks, it is much slower than other methods +considered here. Boost Format also has excessive build times and severe +code bloat issues (see [Benchmarks](#benchmarks)). + +## FastFormat + +This is an interesting library that is fast, safe and has positional +arguments. However, it has significant limitations, citing its author: + +> Three features that have no hope of being accommodated within the +> current design are: +> +> - Leading zeros (or any other non-space padding) +> - Octal/hexadecimal encoding +> - Runtime width/alignment specification + +It is also quite big and has a heavy dependency, on STLSoft, which might be +too restrictive for use in some projects. + +## Boost Spirit.Karma + +This is not a formatting library but I decided to include it here for +completeness. As iostreams, it suffers from the problem of mixing +verbatim text with arguments. The library is pretty fast, but slower on +integer formatting than `fmt::format_to` with format string compilation +on Karma\'s own benchmark, see [Converting a hundred million integers to +strings per +second](http://www.zverovich.net/2020/06/13/fast-int-to-string-revisited.html). + +# License + +{fmt} is distributed under the MIT +[license](https://github.com/fmtlib/fmt/blob/master/LICENSE). + +# Documentation License + +The [Format String Syntax](https://fmt.dev/latest/syntax.html) section +in the documentation is based on the one from Python [string module +documentation](https://docs.python.org/3/library/string.html#module-string). +For this reason, the documentation is distributed under the Python +Software Foundation license available in +[doc/python-license.txt](https://raw.github.com/fmtlib/fmt/master/doc/python-license.txt). +It only applies if you distribute the documentation of {fmt}. + +# Maintainers + +The {fmt} library is maintained by Victor Zverovich +([vitaut](https://github.com/vitaut)) with contributions from many other +people. See +[Contributors](https://github.com/fmtlib/fmt/graphs/contributors) and +[Releases](https://github.com/fmtlib/fmt/releases) for some of the +names. Let us know if your contribution is not listed or mentioned +incorrectly and we\'ll make it right. + +# Security Policy + +To report a security issue, please disclose it at [security +advisory](https://github.com/fmtlib/fmt/security/advisories/new). + +This project is maintained by a team of volunteers on a +reasonable-effort basis. As such, please give us at least *90* days to +work on a fix before public exposure. diff --git a/contrib/fmt/README.rst b/contrib/fmt/README.rst deleted file mode 100644 index acddc70ef..000000000 --- a/contrib/fmt/README.rst +++ /dev/null @@ -1,506 +0,0 @@ -{fmt} -===== - -.. image:: https://travis-ci.org/fmtlib/fmt.png?branch=master - :target: https://travis-ci.org/fmtlib/fmt - -.. image:: https://ci.appveyor.com/api/projects/status/ehjkiefde6gucy1v - :target: https://ci.appveyor.com/project/vitaut/fmt - -.. image:: https://oss-fuzz-build-logs.storage.googleapis.com/badges/fmt.svg - :alt: fmt is continuously fuzzed at oss-fuzz - :target: https://bugs.chromium.org/p/oss-fuzz/issues/list?\ - colspec=ID%20Type%20Component%20Status%20Proj%20Reported%20Owner%20\ - Summary&q=proj%3Dfmt&can=1 - -.. image:: https://img.shields.io/badge/stackoverflow-fmt-blue.svg - :alt: Ask questions at StackOverflow with the tag fmt - :target: https://stackoverflow.com/questions/tagged/fmt - -**{fmt}** is an open-source formatting library providing a fast and safe -alternative to C stdio and C++ iostreams. - -If you like this project, please consider donating to BYSOL, -an initiative to help victims of political repressions in Belarus: -https://www.facebook.com/donate/759400044849707/108388587646909/. - -`Documentation <https://fmt.dev>`__ - -Q&A: ask questions on `StackOverflow with the tag fmt -<https://stackoverflow.com/questions/tagged/fmt>`_. - -Try {fmt} in `Compiler Explorer <https://godbolt.org/z/Eq5763>`_. - -Features --------- - -* Simple `format API <https://fmt.dev/latest/api.html>`_ with positional arguments - for localization -* Implementation of `C++20 std::format - <https://en.cppreference.com/w/cpp/utility/format>`__ -* `Format string syntax <https://fmt.dev/latest/syntax.html>`_ similar to Python's - `format <https://docs.python.org/3/library/stdtypes.html#str.format>`_ -* Fast IEEE 754 floating-point formatter with correct rounding, shortness and - round-trip guarantees -* Safe `printf implementation - <https://fmt.dev/latest/api.html#printf-formatting>`_ including the POSIX - extension for positional arguments -* Extensibility: `support for user-defined types - <https://fmt.dev/latest/api.html#formatting-user-defined-types>`_ -* High performance: faster than common standard library implementations of - ``(s)printf``, iostreams, ``to_string`` and ``to_chars``, see `Speed tests`_ - and `Converting a hundred million integers to strings per second - <http://www.zverovich.net/2020/06/13/fast-int-to-string-revisited.html>`_ -* Small code size both in terms of source code with the minimum configuration - consisting of just three files, ``core.h``, ``format.h`` and ``format-inl.h``, - and compiled code; see `Compile time and code bloat`_ -* Reliability: the library has an extensive set of `tests - <https://github.com/fmtlib/fmt/tree/master/test>`_ and is `continuously fuzzed - <https://bugs.chromium.org/p/oss-fuzz/issues/list?colspec=ID%20Type%20 - Component%20Status%20Proj%20Reported%20Owner%20Summary&q=proj%3Dfmt&can=1>`_ -* Safety: the library is fully type safe, errors in format strings can be - reported at compile time, automatic memory management prevents buffer overflow - errors -* Ease of use: small self-contained code base, no external dependencies, - permissive MIT `license - <https://github.com/fmtlib/fmt/blob/master/LICENSE.rst>`_ -* `Portability <https://fmt.dev/latest/index.html#portability>`_ with - consistent output across platforms and support for older compilers -* Clean warning-free codebase even on high warning levels such as - ``-Wall -Wextra -pedantic`` -* Locale-independence by default -* Optional header-only configuration enabled with the ``FMT_HEADER_ONLY`` macro - -See the `documentation <https://fmt.dev>`_ for more details. - -Examples --------- - -**Print to stdout** (`run <https://godbolt.org/z/Tevcjh>`_) - -.. code:: c++ - - #include <fmt/core.h> - - int main() { - fmt::print("Hello, world!\n"); - } - -**Format a string** (`run <https://godbolt.org/z/oK8h33>`_) - -.. code:: c++ - - std::string s = fmt::format("The answer is {}.", 42); - // s == "The answer is 42." - -**Format a string using positional arguments** (`run <https://godbolt.org/z/Yn7Txe>`_) - -.. code:: c++ - - std::string s = fmt::format("I'd rather be {1} than {0}.", "right", "happy"); - // s == "I'd rather be happy than right." - -**Print chrono durations** (`run <https://godbolt.org/z/K8s4Mc>`_) - -.. code:: c++ - - #include <fmt/chrono.h> - - int main() { - using namespace std::literals::chrono_literals; - fmt::print("Default format: {} {}\n", 42s, 100ms); - fmt::print("strftime-like format: {:%H:%M:%S}\n", 3h + 15min + 30s); - } - -Output:: - - Default format: 42s 100ms - strftime-like format: 03:15:30 - -**Print a container** (`run <https://godbolt.org/z/MjsY7c>`_) - -.. code:: c++ - - #include <vector> - #include <fmt/ranges.h> - - int main() { - std::vector<int> v = {1, 2, 3}; - fmt::print("{}\n", v); - } - -Output:: - - {1, 2, 3} - -**Check a format string at compile time** - -.. code:: c++ - - std::string s = fmt::format(FMT_STRING("{:d}"), "don't panic"); - -This gives a compile-time error because ``d`` is an invalid format specifier for -a string. - -**Write a file from a single thread** - -.. code:: c++ - - #include <fmt/os.h> - - int main() { - auto out = fmt::output_file("guide.txt"); - out.print("Don't {}", "Panic"); - } - -This can be `5 to 9 times faster than fprintf -<http://www.zverovich.net/2020/08/04/optimal-file-buffer-size.html>`_. - -**Print with colors and text styles** - -.. code:: c++ - - #include <fmt/color.h> - - int main() { - fmt::print(fg(fmt::color::crimson) | fmt::emphasis::bold, - "Hello, {}!\n", "world"); - fmt::print(fg(fmt::color::floral_white) | bg(fmt::color::slate_gray) | - fmt::emphasis::underline, "Hello, {}!\n", "мир"); - fmt::print(fg(fmt::color::steel_blue) | fmt::emphasis::italic, - "Hello, {}!\n", "世界"); - } - -Output on a modern terminal: - -.. image:: https://user-images.githubusercontent.com/ - 576385/88485597-d312f600-cf2b-11ea-9cbe-61f535a86e28.png - -Benchmarks ----------- - -Speed tests -~~~~~~~~~~~ - -================= ============= =========== -Library Method Run Time, s -================= ============= =========== -libc printf 1.04 -libc++ std::ostream 3.05 -{fmt} 6.1.1 fmt::print 0.75 -Boost Format 1.67 boost::format 7.24 -Folly Format folly::format 2.23 -================= ============= =========== - -{fmt} is the fastest of the benchmarked methods, ~35% faster than ``printf``. - -The above results were generated by building ``tinyformat_test.cpp`` on macOS -10.14.6 with ``clang++ -O3 -DNDEBUG -DSPEED_TEST -DHAVE_FORMAT``, and taking the -best of three runs. In the test, the format string ``"%0.10f:%04d:%+g:%s:%p:%c:%%\n"`` -or equivalent is filled 2,000,000 times with output sent to ``/dev/null``; for -further details refer to the `source -<https://github.com/fmtlib/format-benchmark/blob/master/tinyformat_test.cpp>`_. - -{fmt} is up to 20-30x faster than ``std::ostringstream`` and ``sprintf`` on -floating-point formatting (`dtoa-benchmark <https://github.com/fmtlib/dtoa-benchmark>`_) -and faster than `double-conversion <https://github.com/google/double-conversion>`_ and -`ryu <https://github.com/ulfjack/ryu>`_: - -.. image:: https://user-images.githubusercontent.com/576385/ - 95684665-11719600-0ba8-11eb-8e5b-972ff4e49428.png - :target: https://fmt.dev/unknown_mac64_clang12.0.html - -Compile time and code bloat -~~~~~~~~~~~~~~~~~~~~~~~~~~~ - -The script `bloat-test.py -<https://github.com/fmtlib/format-benchmark/blob/master/bloat-test.py>`_ -from `format-benchmark <https://github.com/fmtlib/format-benchmark>`_ -tests compile time and code bloat for nontrivial projects. -It generates 100 translation units and uses ``printf()`` or its alternative -five times in each to simulate a medium sized project. The resulting -executable size and compile time (Apple LLVM version 8.1.0 (clang-802.0.42), -macOS Sierra, best of three) is shown in the following tables. - -**Optimized build (-O3)** - -============= =============== ==================== ================== -Method Compile Time, s Executable size, KiB Stripped size, KiB -============= =============== ==================== ================== -printf 2.6 29 26 -printf+string 16.4 29 26 -iostreams 31.1 59 55 -{fmt} 19.0 37 34 -Boost Format 91.9 226 203 -Folly Format 115.7 101 88 -============= =============== ==================== ================== - -As you can see, {fmt} has 60% less overhead in terms of resulting binary code -size compared to iostreams and comes pretty close to ``printf``. Boost Format -and Folly Format have the largest overheads. - -``printf+string`` is the same as ``printf`` but with extra ``<string>`` -include to measure the overhead of the latter. - -**Non-optimized build** - -============= =============== ==================== ================== -Method Compile Time, s Executable size, KiB Stripped size, KiB -============= =============== ==================== ================== -printf 2.2 33 30 -printf+string 16.0 33 30 -iostreams 28.3 56 52 -{fmt} 18.2 59 50 -Boost Format 54.1 365 303 -Folly Format 79.9 445 430 -============= =============== ==================== ================== - -``libc``, ``lib(std)c++`` and ``libfmt`` are all linked as shared libraries to -compare formatting function overhead only. Boost Format is a -header-only library so it doesn't provide any linkage options. - -Running the tests -~~~~~~~~~~~~~~~~~ - -Please refer to `Building the library`__ for the instructions on how to build -the library and run the unit tests. - -__ https://fmt.dev/latest/usage.html#building-the-library - -Benchmarks reside in a separate repository, -`format-benchmarks <https://github.com/fmtlib/format-benchmark>`_, -so to run the benchmarks you first need to clone this repository and -generate Makefiles with CMake:: - - $ git clone --recursive https://github.com/fmtlib/format-benchmark.git - $ cd format-benchmark - $ cmake . - -Then you can run the speed test:: - - $ make speed-test - -or the bloat test:: - - $ make bloat-test - -Projects using this library ---------------------------- - -* `0 A.D. <https://play0ad.com/>`_: a free, open-source, cross-platform - real-time strategy game - -* `AMPL/MP <https://github.com/ampl/mp>`_: - an open-source library for mathematical programming - -* `Aseprite <https://github.com/aseprite/aseprite>`_: - animated sprite editor & pixel art tool - -* `AvioBook <https://www.aviobook.aero/en>`_: a comprehensive aircraft - operations suite - -* `Blizzard Battle.net <https://battle.net/>`_: an online gaming platform - -* `Celestia <https://celestia.space/>`_: real-time 3D visualization of space - -* `Ceph <https://ceph.com/>`_: a scalable distributed storage system - -* `ccache <https://ccache.dev/>`_: a compiler cache - -* `ClickHouse <https://github.com/ClickHouse/ClickHouse>`_: analytical database - management system - -* `CUAUV <http://cuauv.org/>`_: Cornell University's autonomous underwater - vehicle - -* `Drake <https://drake.mit.edu/>`_: a planning, control, and analysis toolbox - for nonlinear dynamical systems (MIT) - -* `Envoy <https://lyft.github.io/envoy/>`_: C++ L7 proxy and communication bus - (Lyft) - -* `FiveM <https://fivem.net/>`_: a modification framework for GTA V - -* `Folly <https://github.com/facebook/folly>`_: Facebook open-source library - -* `HarpyWar/pvpgn <https://github.com/pvpgn/pvpgn-server>`_: - Player vs Player Gaming Network with tweaks - -* `KBEngine <https://github.com/kbengine/kbengine>`_: an open-source MMOG server - engine - -* `Keypirinha <https://keypirinha.com/>`_: a semantic launcher for Windows - -* `Kodi <https://kodi.tv/>`_ (formerly xbmc): home theater software - -* `Knuth <https://kth.cash/>`_: high-performance Bitcoin full-node - -* `Microsoft Verona <https://github.com/microsoft/verona>`_: - research programming language for concurrent ownership - -* `MongoDB <https://mongodb.com/>`_: distributed document database - -* `MongoDB Smasher <https://github.com/duckie/mongo_smasher>`_: a small tool to - generate randomized datasets - -* `OpenSpace <https://openspaceproject.com/>`_: an open-source - astrovisualization framework - -* `PenUltima Online (POL) <https://www.polserver.com/>`_: - an MMO server, compatible with most Ultima Online clients - -* `PyTorch <https://github.com/pytorch/pytorch>`_: an open-source machine - learning library - -* `quasardb <https://www.quasardb.net/>`_: a distributed, high-performance, - associative database - -* `Quill <https://github.com/odygrd/quill>`_: asynchronous low-latency logging library - -* `QKW <https://github.com/ravijanjam/qkw>`_: generalizing aliasing to simplify - navigation, and executing complex multi-line terminal command sequences - -* `redis-cerberus <https://github.com/HunanTV/redis-cerberus>`_: a Redis cluster - proxy - -* `redpanda <https://vectorized.io/redpanda>`_: a 10x faster Kafka® replacement - for mission critical systems written in C++ - -* `rpclib <http://rpclib.net/>`_: a modern C++ msgpack-RPC server and client - library - -* `Salesforce Analytics Cloud - <https://www.salesforce.com/analytics-cloud/overview/>`_: - business intelligence software - -* `Scylla <https://www.scylladb.com/>`_: a Cassandra-compatible NoSQL data store - that can handle 1 million transactions per second on a single server - -* `Seastar <http://www.seastar-project.org/>`_: an advanced, open-source C++ - framework for high-performance server applications on modern hardware - -* `spdlog <https://github.com/gabime/spdlog>`_: super fast C++ logging library - -* `Stellar <https://www.stellar.org/>`_: financial platform - -* `Touch Surgery <https://www.touchsurgery.com/>`_: surgery simulator - -* `TrinityCore <https://github.com/TrinityCore/TrinityCore>`_: open-source - MMORPG framework - -* `Windows Terminal <https://github.com/microsoft/terminal>`_: the new Windows - terminal - -`More... <https://github.com/search?q=fmtlib&type=Code>`_ - -If you are aware of other projects using this library, please let me know -by `email <mailto:victor.zverovich@gmail.com>`_ or by submitting an -`issue <https://github.com/fmtlib/fmt/issues>`_. - -Motivation ----------- - -So why yet another formatting library? - -There are plenty of methods for doing this task, from standard ones like -the printf family of function and iostreams to Boost Format and FastFormat -libraries. The reason for creating a new library is that every existing -solution that I found either had serious issues or didn't provide -all the features I needed. - -printf -~~~~~~ - -The good thing about ``printf`` is that it is pretty fast and readily available -being a part of the C standard library. The main drawback is that it -doesn't support user-defined types. ``printf`` also has safety issues although -they are somewhat mitigated with `__attribute__ ((format (printf, ...)) -<https://gcc.gnu.org/onlinedocs/gcc/Function-Attributes.html>`_ in GCC. -There is a POSIX extension that adds positional arguments required for -`i18n <https://en.wikipedia.org/wiki/Internationalization_and_localization>`_ -to ``printf`` but it is not a part of C99 and may not be available on some -platforms. - -iostreams -~~~~~~~~~ - -The main issue with iostreams is best illustrated with an example: - -.. code:: c++ - - std::cout << std::setprecision(2) << std::fixed << 1.23456 << "\n"; - -which is a lot of typing compared to printf: - -.. code:: c++ - - printf("%.2f\n", 1.23456); - -Matthew Wilson, the author of FastFormat, called this "chevron hell". iostreams -don't support positional arguments by design. - -The good part is that iostreams support user-defined types and are safe although -error handling is awkward. - -Boost Format -~~~~~~~~~~~~ - -This is a very powerful library which supports both ``printf``-like format -strings and positional arguments. Its main drawback is performance. According to -various, benchmarks it is much slower than other methods considered here. Boost -Format also has excessive build times and severe code bloat issues (see -`Benchmarks`_). - -FastFormat -~~~~~~~~~~ - -This is an interesting library which is fast, safe and has positional arguments. -However, it has significant limitations, citing its author: - - Three features that have no hope of being accommodated within the - current design are: - - * Leading zeros (or any other non-space padding) - * Octal/hexadecimal encoding - * Runtime width/alignment specification - -It is also quite big and has a heavy dependency, STLSoft, which might be too -restrictive for using it in some projects. - -Boost Spirit.Karma -~~~~~~~~~~~~~~~~~~ - -This is not really a formatting library but I decided to include it here for -completeness. As iostreams, it suffers from the problem of mixing verbatim text -with arguments. The library is pretty fast, but slower on integer formatting -than ``fmt::format_to`` with format string compilation on Karma's own benchmark, -see `Converting a hundred million integers to strings per second -<http://www.zverovich.net/2020/06/13/fast-int-to-string-revisited.html>`_. - -License -------- - -{fmt} is distributed under the MIT `license -<https://github.com/fmtlib/fmt/blob/master/LICENSE.rst>`_. - -Documentation License ---------------------- - -The `Format String Syntax <https://fmt.dev/latest/syntax.html>`_ -section in the documentation is based on the one from Python `string module -documentation <https://docs.python.org/3/library/string.html#module-string>`_. -For this reason the documentation is distributed under the Python Software -Foundation license available in `doc/python-license.txt -<https://raw.github.com/fmtlib/fmt/master/doc/python-license.txt>`_. -It only applies if you distribute the documentation of {fmt}. - -Maintainers ------------ - -The {fmt} library is maintained by Victor Zverovich (`vitaut -<https://github.com/vitaut>`_) and Jonathan Müller (`foonathan -<https://github.com/foonathan>`_) with contributions from many other people. -See `Contributors <https://github.com/fmtlib/fmt/graphs/contributors>`_ and -`Releases <https://github.com/fmtlib/fmt/releases>`_ for some of the names. -Let us know if your contribution is not listed or mentioned incorrectly and -we'll make it right. diff --git a/contrib/fmt/include/fmt/args.h b/contrib/fmt/include/fmt/args.h index a3966d140..31a60e8fa 100644 --- a/contrib/fmt/include/fmt/args.h +++ b/contrib/fmt/include/fmt/args.h @@ -1,4 +1,4 @@ -// Formatting library for C++ - dynamic format arguments +// Formatting library for C++ - dynamic argument lists // // Copyright (c) 2012 - present, Victor Zverovich // All rights reserved. @@ -8,11 +8,13 @@ #ifndef FMT_ARGS_H_ #define FMT_ARGS_H_ -#include <functional> // std::reference_wrapper -#include <memory> // std::unique_ptr -#include <vector> +#ifndef FMT_MODULE +# include <functional> // std::reference_wrapper +# include <memory> // std::unique_ptr +# include <vector> +#endif -#include "core.h" +#include "format.h" // std_string_view FMT_BEGIN_NAMESPACE @@ -22,20 +24,24 @@ template <typename T> struct is_reference_wrapper : std::false_type {}; template <typename T> struct is_reference_wrapper<std::reference_wrapper<T>> : std::true_type {}; -template <typename T> const T& unwrap(const T& v) { return v; } -template <typename T> const T& unwrap(const std::reference_wrapper<T>& v) { +template <typename T> auto unwrap(const T& v) -> const T& { return v; } +template <typename T> +auto unwrap(const std::reference_wrapper<T>& v) -> const T& { return static_cast<const T&>(v); } -class dynamic_arg_list { - // Workaround for clang's -Wweak-vtables. Unlike for regular classes, for - // templates it doesn't complain about inability to deduce single translation - // unit for placing vtable. So storage_node_base is made a fake template. - template <typename = void> struct node { - virtual ~node() = default; - std::unique_ptr<node<>> next; - }; +// node is defined outside dynamic_arg_list to workaround a C2504 bug in MSVC +// 2022 (v17.10.0). +// +// Workaround for clang's -Wweak-vtables. Unlike for regular classes, for +// templates it doesn't complain about inability to deduce single translation +// unit for placing vtable. So node is made a fake template. +template <typename = void> struct node { + virtual ~node() = default; + std::unique_ptr<node<>> next; +}; +class dynamic_arg_list { template <typename T> struct typed_node : node<> { T value; @@ -50,7 +56,7 @@ class dynamic_arg_list { std::unique_ptr<node<>> head_; public: - template <typename T, typename Arg> const T& push(const Arg& arg) { + template <typename T, typename Arg> auto push(const Arg& arg) -> const T& { auto new_node = std::unique_ptr<typed_node<T>>(new typed_node<T>(arg)); auto& value = new_node->value; new_node->next = std::move(head_); @@ -61,14 +67,10 @@ class dynamic_arg_list { } // namespace detail /** - \rst - A dynamic version of `fmt::format_arg_store`. - It's equipped with a storage to potentially temporary objects which lifetimes - could be shorter than the format arguments object. - - It can be implicitly converted into `~fmt::basic_format_args` for passing - into type-erased formatting functions such as `~fmt::vformat`. - \endrst + * A dynamic list of formatting arguments with storage. + * + * It can be implicitly converted into `fmt::basic_format_args` for passing + * into type-erased formatting functions such as `fmt::vformat`. */ template <typename Context> class dynamic_format_arg_store @@ -110,14 +112,14 @@ class dynamic_format_arg_store friend class basic_format_args<Context>; - unsigned long long get_types() const { + auto get_types() const -> unsigned long long { return detail::is_unpacked_bit | data_.size() | (named_info_.empty() ? 0ULL : static_cast<unsigned long long>(detail::has_named_args_bit)); } - const basic_format_arg<Context>* data() const { + auto data() const -> const basic_format_arg<Context>* { return named_info_.empty() ? data_.data() : data_.data() + 1; } @@ -146,22 +148,20 @@ class dynamic_format_arg_store constexpr dynamic_format_arg_store() = default; /** - \rst - Adds an argument into the dynamic store for later passing to a formatting - function. - - Note that custom types and string types (but not string views) are copied - into the store dynamically allocating memory if necessary. - - **Example**:: - - fmt::dynamic_format_arg_store<fmt::format_context> store; - store.push_back(42); - store.push_back("abc"); - store.push_back(1.5f); - std::string result = fmt::vformat("{} and {} and {}", store); - \endrst - */ + * Adds an argument into the dynamic store for later passing to a formatting + * function. + * + * Note that custom types and string types (but not string views) are copied + * into the store dynamically allocating memory if necessary. + * + * **Example**: + * + * fmt::dynamic_format_arg_store<fmt::format_context> store; + * store.push_back(42); + * store.push_back("abc"); + * store.push_back(1.5f); + * std::string result = fmt::vformat("{} and {} and {}", store); + */ template <typename T> void push_back(const T& arg) { if (detail::const_check(need_copy<T>::value)) emplace_arg(dynamic_args_.push<stored_type<T>>(arg)); @@ -170,20 +170,18 @@ class dynamic_format_arg_store } /** - \rst - Adds a reference to the argument into the dynamic store for later passing to - a formatting function. - - **Example**:: - - fmt::dynamic_format_arg_store<fmt::format_context> store; - char band[] = "Rolling Stones"; - store.push_back(std::cref(band)); - band[9] = 'c'; // Changing str affects the output. - std::string result = fmt::vformat("{}", store); - // result == "Rolling Scones" - \endrst - */ + * Adds a reference to the argument into the dynamic store for later passing + * to a formatting function. + * + * **Example**: + * + * fmt::dynamic_format_arg_store<fmt::format_context> store; + * char band[] = "Rolling Stones"; + * store.push_back(std::cref(band)); + * band[9] = 'c'; // Changing str affects the output. + * std::string result = fmt::vformat("{}", store); + * // result == "Rolling Scones" + */ template <typename T> void push_back(std::reference_wrapper<T> arg) { static_assert( need_copy<T>::value, @@ -192,10 +190,10 @@ class dynamic_format_arg_store } /** - Adds named argument into the dynamic store for later passing to a formatting - function. ``std::reference_wrapper`` is supported to avoid copying of the - argument. The name is always copied into the store. - */ + * Adds named argument into the dynamic store for later passing to a + * formatting function. `std::reference_wrapper` is supported to avoid + * copying of the argument. The name is always copied into the store. + */ template <typename T> void push_back(const detail::named_arg<char_type, T>& arg) { const char_type* arg_name = @@ -208,19 +206,15 @@ class dynamic_format_arg_store } } - /** Erase all elements from the store */ + /// Erase all elements from the store. void clear() { data_.clear(); named_info_.clear(); dynamic_args_ = detail::dynamic_arg_list(); } - /** - \rst - Reserves space to store at least *new_cap* arguments including - *new_cap_named* named arguments. - \endrst - */ + /// Reserves space to store at least `new_cap` arguments including + /// `new_cap_named` named arguments. void reserve(size_t new_cap, size_t new_cap_named) { FMT_ASSERT(new_cap >= new_cap_named, "Set of arguments includes set of named arguments"); diff --git a/contrib/fmt/include/fmt/base.h b/contrib/fmt/include/fmt/base.h new file mode 100644 index 000000000..976402a42 --- /dev/null +++ b/contrib/fmt/include/fmt/base.h @@ -0,0 +1,3061 @@ +// Formatting library for C++ - the base API for char/UTF-8 +// +// Copyright (c) 2012 - present, Victor Zverovich +// All rights reserved. +// +// For the license information refer to format.h. + +#ifndef FMT_BASE_H_ +#define FMT_BASE_H_ + +#if defined(FMT_IMPORT_STD) && !defined(FMT_MODULE) +# define FMT_MODULE +#endif + +#ifndef FMT_MODULE +# include <limits.h> // CHAR_BIT +# include <stdio.h> // FILE +# include <string.h> // strlen + +// <cstddef> is also included transitively from <type_traits>. +# include <cstddef> // std::byte +# include <type_traits> // std::enable_if +#endif + +// The fmt library version in the form major * 10000 + minor * 100 + patch. +#define FMT_VERSION 110000 + +// Detect compiler versions. +#if defined(__clang__) && !defined(__ibmxl__) +# define FMT_CLANG_VERSION (__clang_major__ * 100 + __clang_minor__) +#else +# define FMT_CLANG_VERSION 0 +#endif +#if defined(__GNUC__) && !defined(__clang__) && !defined(__INTEL_COMPILER) +# define FMT_GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__) +#else +# define FMT_GCC_VERSION 0 +#endif +#if defined(__ICL) +# define FMT_ICC_VERSION __ICL +#elif defined(__INTEL_COMPILER) +# define FMT_ICC_VERSION __INTEL_COMPILER +#else +# define FMT_ICC_VERSION 0 +#endif +#if defined(_MSC_VER) +# define FMT_MSC_VERSION _MSC_VER +#else +# define FMT_MSC_VERSION 0 +#endif + +// Detect standard library versions. +#ifdef _GLIBCXX_RELEASE +# define FMT_GLIBCXX_RELEASE _GLIBCXX_RELEASE +#else +# define FMT_GLIBCXX_RELEASE 0 +#endif +#ifdef _LIBCPP_VERSION +# define FMT_LIBCPP_VERSION _LIBCPP_VERSION +#else +# define FMT_LIBCPP_VERSION 0 +#endif + +#ifdef _MSVC_LANG +# define FMT_CPLUSPLUS _MSVC_LANG +#else +# define FMT_CPLUSPLUS __cplusplus +#endif + +// Detect __has_*. +#ifdef __has_feature +# define FMT_HAS_FEATURE(x) __has_feature(x) +#else +# define FMT_HAS_FEATURE(x) 0 +#endif +#ifdef __has_include +# define FMT_HAS_INCLUDE(x) __has_include(x) +#else +# define FMT_HAS_INCLUDE(x) 0 +#endif +#ifdef __has_cpp_attribute +# define FMT_HAS_CPP_ATTRIBUTE(x) __has_cpp_attribute(x) +#else +# define FMT_HAS_CPP_ATTRIBUTE(x) 0 +#endif + +#define FMT_HAS_CPP14_ATTRIBUTE(attribute) \ + (FMT_CPLUSPLUS >= 201402L && FMT_HAS_CPP_ATTRIBUTE(attribute)) + +#define FMT_HAS_CPP17_ATTRIBUTE(attribute) \ + (FMT_CPLUSPLUS >= 201703L && FMT_HAS_CPP_ATTRIBUTE(attribute)) + +// Detect C++14 relaxed constexpr. +#ifdef FMT_USE_CONSTEXPR +// Use the provided definition. +#elif FMT_GCC_VERSION >= 600 && FMT_CPLUSPLUS >= 201402L +// GCC only allows throw in constexpr since version 6: +// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=67371. +# define FMT_USE_CONSTEXPR 1 +#elif FMT_ICC_VERSION +# define FMT_USE_CONSTEXPR 0 // https://github.com/fmtlib/fmt/issues/1628 +#elif FMT_HAS_FEATURE(cxx_relaxed_constexpr) || FMT_MSC_VERSION >= 1912 +# define FMT_USE_CONSTEXPR 1 +#else +# define FMT_USE_CONSTEXPR 0 +#endif +#if FMT_USE_CONSTEXPR +# define FMT_CONSTEXPR constexpr +#else +# define FMT_CONSTEXPR +#endif + +// Detect consteval, C++20 constexpr extensions and std::is_constant_evaluated. +#if !defined(__cpp_lib_is_constant_evaluated) +# define FMT_USE_CONSTEVAL 0 +#elif FMT_CPLUSPLUS < 201709L +# define FMT_USE_CONSTEVAL 0 +#elif FMT_GLIBCXX_RELEASE && FMT_GLIBCXX_RELEASE < 10 +# define FMT_USE_CONSTEVAL 0 +#elif FMT_LIBCPP_VERSION && FMT_LIBCPP_VERSION < 10000 +# define FMT_USE_CONSTEVAL 0 +#elif defined(__apple_build_version__) && __apple_build_version__ < 14000029L +# define FMT_USE_CONSTEVAL 0 // consteval is broken in Apple clang < 14. +#elif FMT_MSC_VERSION && FMT_MSC_VERSION < 1929 +# define FMT_USE_CONSTEVAL 0 // consteval is broken in MSVC VS2019 < 16.10. +#elif defined(__cpp_consteval) +# define FMT_USE_CONSTEVAL 1 +#elif FMT_GCC_VERSION >= 1002 || FMT_CLANG_VERSION >= 1101 +# define FMT_USE_CONSTEVAL 1 +#else +# define FMT_USE_CONSTEVAL 0 +#endif +#if FMT_USE_CONSTEVAL +# define FMT_CONSTEVAL consteval +# define FMT_CONSTEXPR20 constexpr +#else +# define FMT_CONSTEVAL +# define FMT_CONSTEXPR20 +#endif + +#if defined(FMT_USE_NONTYPE_TEMPLATE_ARGS) +// Use the provided definition. +#elif defined(__NVCOMPILER) +# define FMT_USE_NONTYPE_TEMPLATE_ARGS 0 +#elif FMT_GCC_VERSION >= 903 && FMT_CPLUSPLUS >= 201709L +# define FMT_USE_NONTYPE_TEMPLATE_ARGS 1 +#elif defined(__cpp_nontype_template_args) && \ + __cpp_nontype_template_args >= 201911L +# define FMT_USE_NONTYPE_TEMPLATE_ARGS 1 +#elif FMT_CLANG_VERSION >= 1200 && FMT_CPLUSPLUS >= 202002L +# define FMT_USE_NONTYPE_TEMPLATE_ARGS 1 +#else +# define FMT_USE_NONTYPE_TEMPLATE_ARGS 0 +#endif + +#ifdef FMT_USE_CONCEPTS +// Use the provided definition. +#elif defined(__cpp_concepts) +# define FMT_USE_CONCEPTS 1 +#else +# define FMT_USE_CONCEPTS 0 +#endif + +// Check if exceptions are disabled. +#ifdef FMT_EXCEPTIONS +// Use the provided definition. +#elif defined(__GNUC__) && !defined(__EXCEPTIONS) +# define FMT_EXCEPTIONS 0 +#elif FMT_MSC_VERSION && !_HAS_EXCEPTIONS +# define FMT_EXCEPTIONS 0 +#else +# define FMT_EXCEPTIONS 1 +#endif +#if FMT_EXCEPTIONS +# define FMT_TRY try +# define FMT_CATCH(x) catch (x) +#else +# define FMT_TRY if (true) +# define FMT_CATCH(x) if (false) +#endif + +#if FMT_HAS_CPP17_ATTRIBUTE(fallthrough) +# define FMT_FALLTHROUGH [[fallthrough]] +#elif defined(__clang__) +# define FMT_FALLTHROUGH [[clang::fallthrough]] +#elif FMT_GCC_VERSION >= 700 && \ + (!defined(__EDG_VERSION__) || __EDG_VERSION__ >= 520) +# define FMT_FALLTHROUGH [[gnu::fallthrough]] +#else +# define FMT_FALLTHROUGH +#endif + +// Disable [[noreturn]] on MSVC/NVCC because of bogus unreachable code warnings. +#if FMT_HAS_CPP_ATTRIBUTE(noreturn) && !FMT_MSC_VERSION && !defined(__NVCC__) +# define FMT_NORETURN [[noreturn]] +#else +# define FMT_NORETURN +#endif + +#ifndef FMT_NODISCARD +# if FMT_HAS_CPP17_ATTRIBUTE(nodiscard) +# define FMT_NODISCARD [[nodiscard]] +# else +# define FMT_NODISCARD +# endif +#endif + +#ifdef FMT_DEPRECATED +// Use the provided definition. +#elif FMT_HAS_CPP14_ATTRIBUTE(deprecated) +# define FMT_DEPRECATED [[deprecated]] +#else +# define FMT_DEPRECATED /* deprecated */ +#endif + +#ifdef FMT_INLINE +// Use the provided definition. +#elif FMT_GCC_VERSION || FMT_CLANG_VERSION +# define FMT_ALWAYS_INLINE inline __attribute__((always_inline)) +#else +# define FMT_ALWAYS_INLINE inline +#endif +// A version of FMT_INLINE to prevent code bloat in debug mode. +#ifdef NDEBUG +# define FMT_INLINE FMT_ALWAYS_INLINE +#else +# define FMT_INLINE inline +#endif + +#if FMT_GCC_VERSION || FMT_CLANG_VERSION +# define FMT_VISIBILITY(value) __attribute__((visibility(value))) +#else +# define FMT_VISIBILITY(value) +#endif + +#ifndef FMT_GCC_PRAGMA +// Workaround a _Pragma bug https://gcc.gnu.org/bugzilla/show_bug.cgi?id=59884 +// and an nvhpc warning: https://github.com/fmtlib/fmt/pull/2582. +# if FMT_GCC_VERSION >= 504 && !defined(__NVCOMPILER) +# define FMT_GCC_PRAGMA(arg) _Pragma(arg) +# else +# define FMT_GCC_PRAGMA(arg) +# endif +#endif + +// GCC < 5 requires this-> in decltype. +#if FMT_GCC_VERSION && FMT_GCC_VERSION < 500 +# define FMT_DECLTYPE_THIS this-> +#else +# define FMT_DECLTYPE_THIS +#endif + +#if FMT_MSC_VERSION +# define FMT_MSC_WARNING(...) __pragma(warning(__VA_ARGS__)) +# define FMT_UNCHECKED_ITERATOR(It) \ + using _Unchecked_type = It // Mark iterator as checked. +#else +# define FMT_MSC_WARNING(...) +# define FMT_UNCHECKED_ITERATOR(It) using unchecked_type = It +#endif + +#ifndef FMT_BEGIN_NAMESPACE +# define FMT_BEGIN_NAMESPACE \ + namespace fmt { \ + inline namespace v10 { +# define FMT_END_NAMESPACE \ + } \ + } +#endif + +#ifndef FMT_EXPORT +# define FMT_EXPORT +# define FMT_BEGIN_EXPORT +# define FMT_END_EXPORT +#endif + +#if !defined(FMT_HEADER_ONLY) && defined(_WIN32) +# if defined(FMT_LIB_EXPORT) +# define FMT_API __declspec(dllexport) +# elif defined(FMT_SHARED) +# define FMT_API __declspec(dllimport) +# endif +#elif defined(FMT_LIB_EXPORT) || defined(FMT_SHARED) +# define FMT_API FMT_VISIBILITY("default") +#endif +#ifndef FMT_API +# define FMT_API +#endif + +#ifndef FMT_UNICODE +# define FMT_UNICODE 1 +#endif + +// Check if rtti is available. +#ifndef FMT_USE_RTTI +// __RTTI is for EDG compilers. _CPPRTTI is for MSVC. +# if defined(__GXX_RTTI) || FMT_HAS_FEATURE(cxx_rtti) || defined(_CPPRTTI) || \ + defined(__INTEL_RTTI__) || defined(__RTTI) +# define FMT_USE_RTTI 1 +# else +# define FMT_USE_RTTI 0 +# endif +#endif + +#define FMT_FWD(...) static_cast<decltype(__VA_ARGS__)&&>(__VA_ARGS__) + +// Enable minimal optimizations for more compact code in debug mode. +FMT_GCC_PRAGMA("GCC push_options") +#if !defined(__OPTIMIZE__) && !defined(__CUDACC__) +FMT_GCC_PRAGMA("GCC optimize(\"Og\")") +#endif + +FMT_BEGIN_NAMESPACE + +// Implementations of enable_if_t and other metafunctions for older systems. +template <bool B, typename T = void> +using enable_if_t = typename std::enable_if<B, T>::type; +template <bool B, typename T, typename F> +using conditional_t = typename std::conditional<B, T, F>::type; +template <bool B> using bool_constant = std::integral_constant<bool, B>; +template <typename T> +using remove_reference_t = typename std::remove_reference<T>::type; +template <typename T> +using remove_const_t = typename std::remove_const<T>::type; +template <typename T> +using remove_cvref_t = typename std::remove_cv<remove_reference_t<T>>::type; +template <typename T> struct type_identity { + using type = T; +}; +template <typename T> using type_identity_t = typename type_identity<T>::type; +template <typename T> +using make_unsigned_t = typename std::make_unsigned<T>::type; +template <typename T> +using underlying_t = typename std::underlying_type<T>::type; + +#if FMT_GCC_VERSION && FMT_GCC_VERSION < 500 +// A workaround for gcc 4.8 to make void_t work in a SFINAE context. +template <typename...> struct void_t_impl { + using type = void; +}; +template <typename... T> using void_t = typename void_t_impl<T...>::type; +#else +template <typename...> using void_t = void; +#endif + +struct monostate { + constexpr monostate() {} +}; + +// An enable_if helper to be used in template parameters which results in much +// shorter symbols: https://godbolt.org/z/sWw4vP. Extra parentheses are needed +// to workaround a bug in MSVC 2019 (see #1140 and #1186). +#ifdef FMT_DOC +# define FMT_ENABLE_IF(...) +#else +# define FMT_ENABLE_IF(...) fmt::enable_if_t<(__VA_ARGS__), int> = 0 +#endif + +// This is defined in base.h instead of format.h to avoid injecting in std. +// It is a template to avoid undesirable implicit conversions to std::byte. +#ifdef __cpp_lib_byte +template <typename T, FMT_ENABLE_IF(std::is_same<T, std::byte>::value)> +inline auto format_as(T b) -> unsigned char { + return static_cast<unsigned char>(b); +} +#endif + +namespace detail { +// Suppresses "unused variable" warnings with the method described in +// https://herbsutter.com/2009/10/18/mailbag-shutting-up-compiler-warnings/. +// (void)var does not work on many Intel compilers. +template <typename... T> FMT_CONSTEXPR void ignore_unused(const T&...) {} + +constexpr auto is_constant_evaluated(bool default_value = false) noexcept + -> bool { +// Workaround for incompatibility between libstdc++ consteval-based +// std::is_constant_evaluated() implementation and clang-14: +// https://github.com/fmtlib/fmt/issues/3247. +#if FMT_CPLUSPLUS >= 202002L && FMT_GLIBCXX_RELEASE >= 12 && \ + (FMT_CLANG_VERSION >= 1400 && FMT_CLANG_VERSION < 1500) + ignore_unused(default_value); + return __builtin_is_constant_evaluated(); +#elif defined(__cpp_lib_is_constant_evaluated) + ignore_unused(default_value); + return std::is_constant_evaluated(); +#else + return default_value; +#endif +} + +// Suppresses "conditional expression is constant" warnings. +template <typename T> constexpr auto const_check(T value) -> T { return value; } + +FMT_NORETURN FMT_API void assert_fail(const char* file, int line, + const char* message); + +#if defined(FMT_ASSERT) +// Use the provided definition. +#elif defined(NDEBUG) +// FMT_ASSERT is not empty to avoid -Wempty-body. +# define FMT_ASSERT(condition, message) \ + fmt::detail::ignore_unused((condition), (message)) +#else +# define FMT_ASSERT(condition, message) \ + ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \ + ? (void)0 \ + : fmt::detail::assert_fail(__FILE__, __LINE__, (message))) +#endif + +#ifdef FMT_USE_INT128 +// Do nothing. +#elif defined(__SIZEOF_INT128__) && !defined(__NVCC__) && \ + !(FMT_CLANG_VERSION && FMT_MSC_VERSION) +# define FMT_USE_INT128 1 +using int128_opt = __int128_t; // An optional native 128-bit integer. +using uint128_opt = __uint128_t; +template <typename T> inline auto convert_for_visit(T value) -> T { + return value; +} +#else +# define FMT_USE_INT128 0 +#endif +#if !FMT_USE_INT128 +enum class int128_opt {}; +enum class uint128_opt {}; +// Reduce template instantiations. +template <typename T> auto convert_for_visit(T) -> monostate { return {}; } +#endif + +// Casts a nonnegative integer to unsigned. +template <typename Int> +FMT_CONSTEXPR auto to_unsigned(Int value) -> make_unsigned_t<Int> { + FMT_ASSERT(std::is_unsigned<Int>::value || value >= 0, "negative value"); + return static_cast<make_unsigned_t<Int>>(value); +} + +// A heuristic to detect std::string and std::[experimental::]string_view. +// It is mainly used to avoid dependency on <[experimental/]string_view>. +template <typename T, typename Enable = void> +struct is_std_string_like : std::false_type {}; +template <typename T> +struct is_std_string_like<T, void_t<decltype(std::declval<T>().find_first_of( + typename T::value_type(), 0))>> + : std::true_type {}; + +// Returns true iff the literal encoding is UTF-8. +constexpr auto is_utf8_enabled() -> bool { + // Avoid an MSVC sign extension bug: https://github.com/fmtlib/fmt/pull/2297. + using uchar = unsigned char; + return sizeof("\u00A7") == 3 && uchar("\u00A7"[0]) == 0xC2 && + uchar("\u00A7"[1]) == 0xA7; +} +constexpr auto use_utf8() -> bool { + return !FMT_MSC_VERSION || is_utf8_enabled(); +} + +static_assert(!FMT_UNICODE || use_utf8(), + "Unicode support requires compiling with /utf-8"); + +template <typename Char> FMT_CONSTEXPR auto length(const Char* s) -> size_t { + size_t len = 0; + while (*s++) ++len; + return len; +} + +template <typename Char> +FMT_CONSTEXPR auto compare(const Char* s1, const Char* s2, std::size_t n) + -> int { + for (; n != 0; ++s1, ++s2, --n) { + if (*s1 < *s2) return -1; + if (*s1 > *s2) return 1; + } + return 0; +} + +template <typename It, typename Enable = std::true_type> +struct is_back_insert_iterator : std::false_type {}; +template <typename It> +struct is_back_insert_iterator< + It, + bool_constant<std::is_same< + decltype(back_inserter(std::declval<typename It::container_type&>())), + It>::value>> : std::true_type {}; + +// Extracts a reference to the container from *insert_iterator. +template <typename OutputIt> +inline auto get_container(OutputIt it) -> typename OutputIt::container_type& { + struct accessor : OutputIt { + accessor(OutputIt base) : OutputIt(base) {} + using OutputIt::container; + }; + return *accessor(it).container; +} +} // namespace detail + +// Checks whether T is a container with contiguous storage. +template <typename T> struct is_contiguous : std::false_type {}; + +/** + * An implementation of `std::basic_string_view` for pre-C++17. It provides a + * subset of the API. `fmt::basic_string_view` is used for format strings even + * if `std::basic_string_view` is available to prevent issues when a library is + * compiled with a different `-std` option than the client code (which is not + * recommended). + */ +FMT_EXPORT +template <typename Char> class basic_string_view { + private: + const Char* data_; + size_t size_; + + public: + using value_type = Char; + using iterator = const Char*; + + constexpr basic_string_view() noexcept : data_(nullptr), size_(0) {} + + /// Constructs a string reference object from a C string and a size. + constexpr basic_string_view(const Char* s, size_t count) noexcept + : data_(s), size_(count) {} + + constexpr basic_string_view(std::nullptr_t) = delete; + + /// Constructs a string reference object from a C string. + FMT_CONSTEXPR20 + basic_string_view(const Char* s) + : data_(s), + size_(detail::const_check(std::is_same<Char, char>::value && + !detail::is_constant_evaluated(false)) + ? strlen(reinterpret_cast<const char*>(s)) + : detail::length(s)) {} + + /// Constructs a string reference from a `std::basic_string` or a + /// `std::basic_string_view` object. + template <typename S, + FMT_ENABLE_IF(detail::is_std_string_like<S>::value&& std::is_same< + typename S::value_type, Char>::value)> + FMT_CONSTEXPR basic_string_view(const S& s) noexcept + : data_(s.data()), size_(s.size()) {} + + /// Returns a pointer to the string data. + constexpr auto data() const noexcept -> const Char* { return data_; } + + /// Returns the string size. + constexpr auto size() const noexcept -> size_t { return size_; } + + constexpr auto begin() const noexcept -> iterator { return data_; } + constexpr auto end() const noexcept -> iterator { return data_ + size_; } + + constexpr auto operator[](size_t pos) const noexcept -> const Char& { + return data_[pos]; + } + + FMT_CONSTEXPR void remove_prefix(size_t n) noexcept { + data_ += n; + size_ -= n; + } + + FMT_CONSTEXPR auto starts_with(basic_string_view<Char> sv) const noexcept + -> bool { + return size_ >= sv.size_ && detail::compare(data_, sv.data_, sv.size_) == 0; + } + FMT_CONSTEXPR auto starts_with(Char c) const noexcept -> bool { + return size_ >= 1 && *data_ == c; + } + FMT_CONSTEXPR auto starts_with(const Char* s) const -> bool { + return starts_with(basic_string_view<Char>(s)); + } + + // Lexicographically compare this string reference to other. + FMT_CONSTEXPR auto compare(basic_string_view other) const -> int { + size_t str_size = size_ < other.size_ ? size_ : other.size_; + int result = detail::compare(data_, other.data_, str_size); + if (result == 0) + result = size_ == other.size_ ? 0 : (size_ < other.size_ ? -1 : 1); + return result; + } + + FMT_CONSTEXPR friend auto operator==(basic_string_view lhs, + basic_string_view rhs) -> bool { + return lhs.compare(rhs) == 0; + } + friend auto operator!=(basic_string_view lhs, basic_string_view rhs) -> bool { + return lhs.compare(rhs) != 0; + } + friend auto operator<(basic_string_view lhs, basic_string_view rhs) -> bool { + return lhs.compare(rhs) < 0; + } + friend auto operator<=(basic_string_view lhs, basic_string_view rhs) -> bool { + return lhs.compare(rhs) <= 0; + } + friend auto operator>(basic_string_view lhs, basic_string_view rhs) -> bool { + return lhs.compare(rhs) > 0; + } + friend auto operator>=(basic_string_view lhs, basic_string_view rhs) -> bool { + return lhs.compare(rhs) >= 0; + } +}; + +FMT_EXPORT +using string_view = basic_string_view<char>; + +/// Specifies if `T` is a character type. Can be specialized by users. +FMT_EXPORT +template <typename T> struct is_char : std::false_type {}; +template <> struct is_char<char> : std::true_type {}; + +namespace detail { + +// Constructs fmt::basic_string_view<Char> from types implicitly convertible +// to it, deducing Char. Explicitly convertible types such as the ones returned +// from FMT_STRING are intentionally excluded. +template <typename Char, FMT_ENABLE_IF(is_char<Char>::value)> +auto to_string_view(const Char* s) -> basic_string_view<Char> { + return s; +} +template <typename T, FMT_ENABLE_IF(is_std_string_like<T>::value)> +auto to_string_view(const T& s) -> basic_string_view<typename T::value_type> { + return s; +} +template <typename Char> +constexpr auto to_string_view(basic_string_view<Char> s) + -> basic_string_view<Char> { + return s; +} + +template <typename T, typename Enable = void> +struct has_to_string_view : std::false_type {}; +// detail:: is intentional since to_string_view is not an extension point. +template <typename T> +struct has_to_string_view< + T, void_t<decltype(detail::to_string_view(std::declval<T>()))>> + : std::true_type {}; + +template <typename Char, Char... C> struct string_literal { + static constexpr Char value[sizeof...(C)] = {C...}; + constexpr operator basic_string_view<Char>() const { + return {value, sizeof...(C)}; + } +}; +#if FMT_CPLUSPLUS < 201703L +template <typename Char, Char... C> +constexpr Char string_literal<Char, C...>::value[sizeof...(C)]; +#endif + +enum class type { + none_type, + // Integer types should go first, + int_type, + uint_type, + long_long_type, + ulong_long_type, + int128_type, + uint128_type, + bool_type, + char_type, + last_integer_type = char_type, + // followed by floating-point types. + float_type, + double_type, + long_double_type, + last_numeric_type = long_double_type, + cstring_type, + string_type, + pointer_type, + custom_type +}; + +// Maps core type T to the corresponding type enum constant. +template <typename T, typename Char> +struct type_constant : std::integral_constant<type, type::custom_type> {}; + +#define FMT_TYPE_CONSTANT(Type, constant) \ + template <typename Char> \ + struct type_constant<Type, Char> \ + : std::integral_constant<type, type::constant> {} + +FMT_TYPE_CONSTANT(int, int_type); +FMT_TYPE_CONSTANT(unsigned, uint_type); +FMT_TYPE_CONSTANT(long long, long_long_type); +FMT_TYPE_CONSTANT(unsigned long long, ulong_long_type); +FMT_TYPE_CONSTANT(int128_opt, int128_type); +FMT_TYPE_CONSTANT(uint128_opt, uint128_type); +FMT_TYPE_CONSTANT(bool, bool_type); +FMT_TYPE_CONSTANT(Char, char_type); +FMT_TYPE_CONSTANT(float, float_type); +FMT_TYPE_CONSTANT(double, double_type); +FMT_TYPE_CONSTANT(long double, long_double_type); +FMT_TYPE_CONSTANT(const Char*, cstring_type); +FMT_TYPE_CONSTANT(basic_string_view<Char>, string_type); +FMT_TYPE_CONSTANT(const void*, pointer_type); + +constexpr auto is_integral_type(type t) -> bool { + return t > type::none_type && t <= type::last_integer_type; +} +constexpr auto is_arithmetic_type(type t) -> bool { + return t > type::none_type && t <= type::last_numeric_type; +} + +constexpr auto set(type rhs) -> int { return 1 << static_cast<int>(rhs); } +constexpr auto in(type t, int set) -> bool { + return ((set >> static_cast<int>(t)) & 1) != 0; +} + +// Bitsets of types. +enum { + sint_set = + set(type::int_type) | set(type::long_long_type) | set(type::int128_type), + uint_set = set(type::uint_type) | set(type::ulong_long_type) | + set(type::uint128_type), + bool_set = set(type::bool_type), + char_set = set(type::char_type), + float_set = set(type::float_type) | set(type::double_type) | + set(type::long_double_type), + string_set = set(type::string_type), + cstring_set = set(type::cstring_type), + pointer_set = set(type::pointer_type) +}; +} // namespace detail + +/// Reports a format error at compile time or, via a `format_error` exception, +/// at runtime. +// This function is intentionally not constexpr to give a compile-time error. +FMT_NORETURN FMT_API void report_error(const char* message); + +FMT_DEPRECATED FMT_NORETURN inline void throw_format_error( + const char* message) { + report_error(message); +} + +/// String's character (code unit) type. +template <typename S, + typename V = decltype(detail::to_string_view(std::declval<S>()))> +using char_t = typename V::value_type; + +/** + * Parsing context consisting of a format string range being parsed and an + * argument counter for automatic indexing. + * You can use the `format_parse_context` type alias for `char` instead. + */ +FMT_EXPORT +template <typename Char> class basic_format_parse_context { + private: + basic_string_view<Char> format_str_; + int next_arg_id_; + + FMT_CONSTEXPR void do_check_arg_id(int id); + + public: + using char_type = Char; + using iterator = const Char*; + + explicit constexpr basic_format_parse_context( + basic_string_view<Char> format_str, int next_arg_id = 0) + : format_str_(format_str), next_arg_id_(next_arg_id) {} + + /// Returns an iterator to the beginning of the format string range being + /// parsed. + constexpr auto begin() const noexcept -> iterator { + return format_str_.begin(); + } + + /// Returns an iterator past the end of the format string range being parsed. + constexpr auto end() const noexcept -> iterator { return format_str_.end(); } + + /// Advances the begin iterator to `it`. + FMT_CONSTEXPR void advance_to(iterator it) { + format_str_.remove_prefix(detail::to_unsigned(it - begin())); + } + + /// Reports an error if using the manual argument indexing; otherwise returns + /// the next argument index and switches to the automatic indexing. + FMT_CONSTEXPR auto next_arg_id() -> int { + if (next_arg_id_ < 0) { + report_error("cannot switch from manual to automatic argument indexing"); + return 0; + } + int id = next_arg_id_++; + do_check_arg_id(id); + return id; + } + + /// Reports an error if using the automatic argument indexing; otherwise + /// switches to the manual indexing. + FMT_CONSTEXPR void check_arg_id(int id) { + if (next_arg_id_ > 0) { + report_error("cannot switch from automatic to manual argument indexing"); + return; + } + next_arg_id_ = -1; + do_check_arg_id(id); + } + FMT_CONSTEXPR void check_arg_id(basic_string_view<Char>) { + next_arg_id_ = -1; + } + FMT_CONSTEXPR void check_dynamic_spec(int arg_id); +}; + +FMT_EXPORT +using format_parse_context = basic_format_parse_context<char>; + +namespace detail { +// A parse context with extra data used only in compile-time checks. +template <typename Char> +class compile_parse_context : public basic_format_parse_context<Char> { + private: + int num_args_; + const type* types_; + using base = basic_format_parse_context<Char>; + + public: + explicit FMT_CONSTEXPR compile_parse_context( + basic_string_view<Char> format_str, int num_args, const type* types, + int next_arg_id = 0) + : base(format_str, next_arg_id), num_args_(num_args), types_(types) {} + + constexpr auto num_args() const -> int { return num_args_; } + constexpr auto arg_type(int id) const -> type { return types_[id]; } + + FMT_CONSTEXPR auto next_arg_id() -> int { + int id = base::next_arg_id(); + if (id >= num_args_) report_error("argument not found"); + return id; + } + + FMT_CONSTEXPR void check_arg_id(int id) { + base::check_arg_id(id); + if (id >= num_args_) report_error("argument not found"); + } + using base::check_arg_id; + + FMT_CONSTEXPR void check_dynamic_spec(int arg_id) { + detail::ignore_unused(arg_id); + if (arg_id < num_args_ && types_ && !is_integral_type(types_[arg_id])) + report_error("width/precision is not integer"); + } +}; + +/// A contiguous memory buffer with an optional growing ability. It is an +/// internal class and shouldn't be used directly, only via `memory_buffer`. +template <typename T> class buffer { + private: + T* ptr_; + size_t size_; + size_t capacity_; + + using grow_fun = void (*)(buffer& buf, size_t capacity); + grow_fun grow_; + + protected: + // Don't initialize ptr_ since it is not accessed to save a few cycles. + FMT_MSC_WARNING(suppress : 26495) + FMT_CONSTEXPR20 buffer(grow_fun grow, size_t sz) noexcept + : size_(sz), capacity_(sz), grow_(grow) {} + + constexpr buffer(grow_fun grow, T* p = nullptr, size_t sz = 0, + size_t cap = 0) noexcept + : ptr_(p), size_(sz), capacity_(cap), grow_(grow) {} + + FMT_CONSTEXPR20 ~buffer() = default; + buffer(buffer&&) = default; + + /// Sets the buffer data and capacity. + FMT_CONSTEXPR void set(T* buf_data, size_t buf_capacity) noexcept { + ptr_ = buf_data; + capacity_ = buf_capacity; + } + + public: + using value_type = T; + using const_reference = const T&; + + buffer(const buffer&) = delete; + void operator=(const buffer&) = delete; + + auto begin() noexcept -> T* { return ptr_; } + auto end() noexcept -> T* { return ptr_ + size_; } + + auto begin() const noexcept -> const T* { return ptr_; } + auto end() const noexcept -> const T* { return ptr_ + size_; } + + /// Returns the size of this buffer. + constexpr auto size() const noexcept -> size_t { return size_; } + + /// Returns the capacity of this buffer. + constexpr auto capacity() const noexcept -> size_t { return capacity_; } + + /// Returns a pointer to the buffer data (not null-terminated). + FMT_CONSTEXPR auto data() noexcept -> T* { return ptr_; } + FMT_CONSTEXPR auto data() const noexcept -> const T* { return ptr_; } + + /// Clears this buffer. + void clear() { size_ = 0; } + + // Tries resizing the buffer to contain `count` elements. If T is a POD type + // the new elements may not be initialized. + FMT_CONSTEXPR void try_resize(size_t count) { + try_reserve(count); + size_ = count <= capacity_ ? count : capacity_; + } + + // Tries increasing the buffer capacity to `new_capacity`. It can increase the + // capacity by a smaller amount than requested but guarantees there is space + // for at least one additional element either by increasing the capacity or by + // flushing the buffer if it is full. + FMT_CONSTEXPR void try_reserve(size_t new_capacity) { + if (new_capacity > capacity_) grow_(*this, new_capacity); + } + + FMT_CONSTEXPR void push_back(const T& value) { + try_reserve(size_ + 1); + ptr_[size_++] = value; + } + + /// Appends data to the end of the buffer. + template <typename U> void append(const U* begin, const U* end) { + while (begin != end) { + auto count = to_unsigned(end - begin); + try_reserve(size_ + count); + auto free_cap = capacity_ - size_; + if (free_cap < count) count = free_cap; + if (std::is_same<T, U>::value) { + memcpy(ptr_ + size_, begin, count * sizeof(T)); + } else { + T* out = ptr_ + size_; + for (size_t i = 0; i < count; ++i) out[i] = begin[i]; + } + size_ += count; + begin += count; + } + } + + template <typename Idx> FMT_CONSTEXPR auto operator[](Idx index) -> T& { + return ptr_[index]; + } + template <typename Idx> + FMT_CONSTEXPR auto operator[](Idx index) const -> const T& { + return ptr_[index]; + } +}; + +struct buffer_traits { + explicit buffer_traits(size_t) {} + auto count() const -> size_t { return 0; } + auto limit(size_t size) -> size_t { return size; } +}; + +class fixed_buffer_traits { + private: + size_t count_ = 0; + size_t limit_; + + public: + explicit fixed_buffer_traits(size_t limit) : limit_(limit) {} + auto count() const -> size_t { return count_; } + auto limit(size_t size) -> size_t { + size_t n = limit_ > count_ ? limit_ - count_ : 0; + count_ += size; + return size < n ? size : n; + } +}; + +// A buffer that writes to an output iterator when flushed. +template <typename OutputIt, typename T, typename Traits = buffer_traits> +class iterator_buffer : public Traits, public buffer<T> { + private: + OutputIt out_; + enum { buffer_size = 256 }; + T data_[buffer_size]; + + static FMT_CONSTEXPR void grow(buffer<T>& buf, size_t) { + if (buf.size() == buffer_size) static_cast<iterator_buffer&>(buf).flush(); + } + + void flush() { + auto size = this->size(); + this->clear(); + const T* begin = data_; + const T* end = begin + this->limit(size); + while (begin != end) *out_++ = *begin++; + } + + public: + explicit iterator_buffer(OutputIt out, size_t n = buffer_size) + : Traits(n), buffer<T>(grow, data_, 0, buffer_size), out_(out) {} + iterator_buffer(iterator_buffer&& other) noexcept + : Traits(other), + buffer<T>(grow, data_, 0, buffer_size), + out_(other.out_) {} + ~iterator_buffer() { + // Don't crash if flush fails during unwinding. + FMT_TRY { flush(); } + FMT_CATCH(...) {} + } + + auto out() -> OutputIt { + flush(); + return out_; + } + auto count() const -> size_t { return Traits::count() + this->size(); } +}; + +template <typename T> +class iterator_buffer<T*, T, fixed_buffer_traits> : public fixed_buffer_traits, + public buffer<T> { + private: + T* out_; + enum { buffer_size = 256 }; + T data_[buffer_size]; + + static FMT_CONSTEXPR void grow(buffer<T>& buf, size_t) { + if (buf.size() == buf.capacity()) + static_cast<iterator_buffer&>(buf).flush(); + } + + void flush() { + size_t n = this->limit(this->size()); + if (this->data() == out_) { + out_ += n; + this->set(data_, buffer_size); + } + this->clear(); + } + + public: + explicit iterator_buffer(T* out, size_t n = buffer_size) + : fixed_buffer_traits(n), buffer<T>(grow, out, 0, n), out_(out) {} + iterator_buffer(iterator_buffer&& other) noexcept + : fixed_buffer_traits(other), + buffer<T>(static_cast<iterator_buffer&&>(other)), + out_(other.out_) { + if (this->data() != out_) { + this->set(data_, buffer_size); + this->clear(); + } + } + ~iterator_buffer() { flush(); } + + auto out() -> T* { + flush(); + return out_; + } + auto count() const -> size_t { + return fixed_buffer_traits::count() + this->size(); + } +}; + +template <typename T> class iterator_buffer<T*, T> : public buffer<T> { + public: + explicit iterator_buffer(T* out, size_t = 0) + : buffer<T>([](buffer<T>&, size_t) {}, out, 0, ~size_t()) {} + + auto out() -> T* { return &*this->end(); } +}; + +// A buffer that writes to a container with the contiguous storage. +template <typename OutputIt> +class iterator_buffer< + OutputIt, + enable_if_t<detail::is_back_insert_iterator<OutputIt>::value && + is_contiguous<typename OutputIt::container_type>::value, + typename OutputIt::container_type::value_type>> + : public buffer<typename OutputIt::container_type::value_type> { + private: + using container_type = typename OutputIt::container_type; + using value_type = typename container_type::value_type; + container_type& container_; + + static FMT_CONSTEXPR void grow(buffer<value_type>& buf, size_t capacity) { + auto& self = static_cast<iterator_buffer&>(buf); + self.container_.resize(capacity); + self.set(&self.container_[0], capacity); + } + + public: + explicit iterator_buffer(container_type& c) + : buffer<value_type>(grow, c.size()), container_(c) {} + explicit iterator_buffer(OutputIt out, size_t = 0) + : iterator_buffer(get_container(out)) {} + + auto out() -> OutputIt { return back_inserter(container_); } +}; + +// A buffer that counts the number of code units written discarding the output. +template <typename T = char> class counting_buffer : public buffer<T> { + private: + enum { buffer_size = 256 }; + T data_[buffer_size]; + size_t count_ = 0; + + static FMT_CONSTEXPR void grow(buffer<T>& buf, size_t) { + if (buf.size() != buffer_size) return; + static_cast<counting_buffer&>(buf).count_ += buf.size(); + buf.clear(); + } + + public: + counting_buffer() : buffer<T>(grow, data_, 0, buffer_size) {} + + auto count() -> size_t { return count_ + this->size(); } +}; +} // namespace detail + +template <typename Char> +FMT_CONSTEXPR void basic_format_parse_context<Char>::do_check_arg_id(int id) { + // Argument id is only checked at compile-time during parsing because + // formatting has its own validation. + if (detail::is_constant_evaluated() && + (!FMT_GCC_VERSION || FMT_GCC_VERSION >= 1200)) { + using context = detail::compile_parse_context<Char>; + if (id >= static_cast<context*>(this)->num_args()) + report_error("argument not found"); + } +} + +template <typename Char> +FMT_CONSTEXPR void basic_format_parse_context<Char>::check_dynamic_spec( + int arg_id) { + if (detail::is_constant_evaluated() && + (!FMT_GCC_VERSION || FMT_GCC_VERSION >= 1200)) { + using context = detail::compile_parse_context<Char>; + static_cast<context*>(this)->check_dynamic_spec(arg_id); + } +} + +FMT_EXPORT template <typename Context> class basic_format_arg; +FMT_EXPORT template <typename Context> class basic_format_args; +FMT_EXPORT template <typename Context> class dynamic_format_arg_store; + +// A formatter for objects of type T. +FMT_EXPORT +template <typename T, typename Char = char, typename Enable = void> +struct formatter { + // A deleted default constructor indicates a disabled formatter. + formatter() = delete; +}; + +// Specifies if T has an enabled formatter specialization. A type can be +// formattable even if it doesn't have a formatter e.g. via a conversion. +template <typename T, typename Context> +using has_formatter = + std::is_constructible<typename Context::template formatter_type<T>>; + +// An output iterator that appends to a buffer. It is used instead of +// back_insert_iterator to reduce symbol sizes and avoid <iterator> dependency. +template <typename T> class basic_appender { + private: + detail::buffer<T>* buffer_; + + friend auto get_container(basic_appender app) -> detail::buffer<T>& { + return *app.buffer_; + } + + public: + using iterator_category = int; + using value_type = T; + using difference_type = ptrdiff_t; + using pointer = T*; + using reference = T&; + FMT_UNCHECKED_ITERATOR(basic_appender); + + FMT_CONSTEXPR basic_appender(detail::buffer<T>& buf) : buffer_(&buf) {} + + auto operator=(T c) -> basic_appender& { + buffer_->push_back(c); + return *this; + } + auto operator*() -> basic_appender& { return *this; } + auto operator++() -> basic_appender& { return *this; } + auto operator++(int) -> basic_appender { return *this; } +}; + +using appender = basic_appender<char>; + +namespace detail { + +template <typename T, typename Enable = void> +struct locking : std::true_type {}; +template <typename T> +struct locking<T, void_t<typename formatter<remove_cvref_t<T>>::nonlocking>> + : std::false_type {}; + +template <typename T = int> FMT_CONSTEXPR inline auto is_locking() -> bool { + return locking<T>::value; +} +template <typename T1, typename T2, typename... Tail> +FMT_CONSTEXPR inline auto is_locking() -> bool { + return locking<T1>::value || is_locking<T2, Tail...>(); +} + +// An optimized version of std::copy with the output value type (T). +template <typename T, typename InputIt> +auto copy(InputIt begin, InputIt end, appender out) -> appender { + get_container(out).append(begin, end); + return out; +} + +template <typename T, typename InputIt, typename OutputIt, + FMT_ENABLE_IF(is_back_insert_iterator<OutputIt>::value)> +auto copy(InputIt begin, InputIt end, OutputIt out) -> OutputIt { + get_container(out).append(begin, end); + return out; +} + +template <typename T, typename InputIt, typename OutputIt, + FMT_ENABLE_IF(!is_back_insert_iterator<OutputIt>::value)> +FMT_CONSTEXPR auto copy(InputIt begin, InputIt end, OutputIt out) -> OutputIt { + while (begin != end) *out++ = static_cast<T>(*begin++); + return out; +} + +template <typename T> +FMT_CONSTEXPR auto copy(const T* begin, const T* end, T* out) -> T* { + if (is_constant_evaluated()) return copy<T, const T*, T*>(begin, end, out); + auto size = to_unsigned(end - begin); + if (size > 0) memcpy(out, begin, size * sizeof(T)); + return out + size; +} + +template <typename T, typename V, typename OutputIt> +FMT_CONSTEXPR auto copy(basic_string_view<V> s, OutputIt out) -> OutputIt { + return copy<T>(s.begin(), s.end(), out); +} + +template <typename Context, typename T> +constexpr auto has_const_formatter_impl(T*) + -> decltype(typename Context::template formatter_type<T>().format( + std::declval<const T&>(), std::declval<Context&>()), + true) { + return true; +} +template <typename Context> +constexpr auto has_const_formatter_impl(...) -> bool { + return false; +} +template <typename T, typename Context> +constexpr auto has_const_formatter() -> bool { + return has_const_formatter_impl<Context>(static_cast<T*>(nullptr)); +} + +// Maps an output iterator to a buffer. +template <typename T, typename OutputIt> +auto get_buffer(OutputIt out) -> iterator_buffer<OutputIt, T> { + return iterator_buffer<OutputIt, T>(out); +} +template <typename T> auto get_buffer(basic_appender<T> out) -> buffer<T>& { + return get_container(out); +} + +template <typename Buf, typename OutputIt> +auto get_iterator(Buf& buf, OutputIt) -> decltype(buf.out()) { + return buf.out(); +} +template <typename T, typename OutputIt> +auto get_iterator(buffer<T>&, OutputIt out) -> OutputIt { + return out; +} + +struct view {}; + +template <typename Char, typename T> struct named_arg : view { + const Char* name; + const T& value; + named_arg(const Char* n, const T& v) : name(n), value(v) {} +}; + +template <typename Char> struct named_arg_info { + const Char* name; + int id; +}; + +template <typename T> struct is_named_arg : std::false_type {}; +template <typename T> struct is_statically_named_arg : std::false_type {}; + +template <typename T, typename Char> +struct is_named_arg<named_arg<Char, T>> : std::true_type {}; + +template <bool B = false> constexpr auto count() -> size_t { return B ? 1 : 0; } +template <bool B1, bool B2, bool... Tail> constexpr auto count() -> size_t { + return (B1 ? 1 : 0) + count<B2, Tail...>(); +} + +template <typename... Args> constexpr auto count_named_args() -> size_t { + return count<is_named_arg<Args>::value...>(); +} + +template <typename... Args> +constexpr auto count_statically_named_args() -> size_t { + return count<is_statically_named_arg<Args>::value...>(); +} + +struct unformattable {}; +struct unformattable_char : unformattable {}; +struct unformattable_pointer : unformattable {}; + +template <typename Char> struct string_value { + const Char* data; + size_t size; +}; + +template <typename Char> struct named_arg_value { + const named_arg_info<Char>* data; + size_t size; +}; + +template <typename Context> struct custom_value { + using parse_context = typename Context::parse_context_type; + void* value; + void (*format)(void* arg, parse_context& parse_ctx, Context& ctx); +}; + +// A formatting argument value. +template <typename Context> class value { + public: + using char_type = typename Context::char_type; + + union { + monostate no_value; + int int_value; + unsigned uint_value; + long long long_long_value; + unsigned long long ulong_long_value; + int128_opt int128_value; + uint128_opt uint128_value; + bool bool_value; + char_type char_value; + float float_value; + double double_value; + long double long_double_value; + const void* pointer; + string_value<char_type> string; + custom_value<Context> custom; + named_arg_value<char_type> named_args; + }; + + constexpr FMT_ALWAYS_INLINE value() : no_value() {} + constexpr FMT_ALWAYS_INLINE value(int val) : int_value(val) {} + constexpr FMT_ALWAYS_INLINE value(unsigned val) : uint_value(val) {} + constexpr FMT_ALWAYS_INLINE value(long long val) : long_long_value(val) {} + constexpr FMT_ALWAYS_INLINE value(unsigned long long val) + : ulong_long_value(val) {} + FMT_ALWAYS_INLINE value(int128_opt val) : int128_value(val) {} + FMT_ALWAYS_INLINE value(uint128_opt val) : uint128_value(val) {} + constexpr FMT_ALWAYS_INLINE value(float val) : float_value(val) {} + constexpr FMT_ALWAYS_INLINE value(double val) : double_value(val) {} + FMT_ALWAYS_INLINE value(long double val) : long_double_value(val) {} + constexpr FMT_ALWAYS_INLINE value(bool val) : bool_value(val) {} + constexpr FMT_ALWAYS_INLINE value(char_type val) : char_value(val) {} + FMT_CONSTEXPR FMT_ALWAYS_INLINE value(const char_type* val) { + string.data = val; + if (is_constant_evaluated()) string.size = {}; + } + FMT_CONSTEXPR FMT_ALWAYS_INLINE value(basic_string_view<char_type> val) { + string.data = val.data(); + string.size = val.size(); + } + FMT_ALWAYS_INLINE value(const void* val) : pointer(val) {} + FMT_ALWAYS_INLINE value(const named_arg_info<char_type>* args, size_t size) + : named_args{args, size} {} + + template <typename T> FMT_CONSTEXPR20 FMT_ALWAYS_INLINE value(T& val) { + using value_type = remove_const_t<T>; + // T may overload operator& e.g. std::vector<bool>::reference in libc++. +#if defined(__cpp_if_constexpr) + if constexpr (std::is_same<decltype(&val), T*>::value) + custom.value = const_cast<value_type*>(&val); +#endif + if (!is_constant_evaluated()) + custom.value = const_cast<char*>(&reinterpret_cast<const char&>(val)); + // Get the formatter type through the context to allow different contexts + // have different extension points, e.g. `formatter<T>` for `format` and + // `printf_formatter<T>` for `printf`. + custom.format = format_custom_arg< + value_type, typename Context::template formatter_type<value_type>>; + } + value(unformattable); + value(unformattable_char); + value(unformattable_pointer); + + private: + // Formats an argument of a custom type, such as a user-defined class. + template <typename T, typename Formatter> + static void format_custom_arg(void* arg, + typename Context::parse_context_type& parse_ctx, + Context& ctx) { + auto f = Formatter(); + parse_ctx.advance_to(f.parse(parse_ctx)); + using qualified_type = + conditional_t<has_const_formatter<T, Context>(), const T, T>; + // format must be const for compatibility with std::format and compilation. + const auto& cf = f; + ctx.advance_to(cf.format(*static_cast<qualified_type*>(arg), ctx)); + } +}; + +// To minimize the number of types we need to deal with, long is translated +// either to int or to long long depending on its size. +enum { long_short = sizeof(long) == sizeof(int) }; +using long_type = conditional_t<long_short, int, long long>; +using ulong_type = conditional_t<long_short, unsigned, unsigned long long>; + +template <typename T> struct format_as_result { + template <typename U, + FMT_ENABLE_IF(std::is_enum<U>::value || std::is_class<U>::value)> + static auto map(U*) -> remove_cvref_t<decltype(format_as(std::declval<U>()))>; + static auto map(...) -> void; + + using type = decltype(map(static_cast<T*>(nullptr))); +}; +template <typename T> using format_as_t = typename format_as_result<T>::type; + +template <typename T> +struct has_format_as + : bool_constant<!std::is_same<format_as_t<T>, void>::value> {}; + +#define FMT_MAP_API FMT_CONSTEXPR FMT_ALWAYS_INLINE + +// Maps formatting arguments to core types. +// arg_mapper reports errors by returning unformattable instead of using +// static_assert because it's used in the is_formattable trait. +template <typename Context> struct arg_mapper { + using char_type = typename Context::char_type; + + FMT_MAP_API auto map(signed char val) -> int { return val; } + FMT_MAP_API auto map(unsigned char val) -> unsigned { return val; } + FMT_MAP_API auto map(short val) -> int { return val; } + FMT_MAP_API auto map(unsigned short val) -> unsigned { return val; } + FMT_MAP_API auto map(int val) -> int { return val; } + FMT_MAP_API auto map(unsigned val) -> unsigned { return val; } + FMT_MAP_API auto map(long val) -> long_type { return val; } + FMT_MAP_API auto map(unsigned long val) -> ulong_type { return val; } + FMT_MAP_API auto map(long long val) -> long long { return val; } + FMT_MAP_API auto map(unsigned long long val) -> unsigned long long { + return val; + } + FMT_MAP_API auto map(int128_opt val) -> int128_opt { return val; } + FMT_MAP_API auto map(uint128_opt val) -> uint128_opt { return val; } + FMT_MAP_API auto map(bool val) -> bool { return val; } + + template <typename T, FMT_ENABLE_IF(std::is_same<T, char>::value || + std::is_same<T, char_type>::value)> + FMT_MAP_API auto map(T val) -> char_type { + return val; + } + template <typename T, enable_if_t<(std::is_same<T, wchar_t>::value || +#ifdef __cpp_char8_t + std::is_same<T, char8_t>::value || +#endif + std::is_same<T, char16_t>::value || + std::is_same<T, char32_t>::value) && + !std::is_same<T, char_type>::value, + int> = 0> + FMT_MAP_API auto map(T) -> unformattable_char { + return {}; + } + + FMT_MAP_API auto map(float val) -> float { return val; } + FMT_MAP_API auto map(double val) -> double { return val; } + FMT_MAP_API auto map(long double val) -> long double { return val; } + + FMT_MAP_API auto map(char_type* val) -> const char_type* { return val; } + FMT_MAP_API auto map(const char_type* val) -> const char_type* { return val; } + template <typename T, typename Char = char_t<T>, + FMT_ENABLE_IF(std::is_same<Char, char_type>::value && + !std::is_pointer<T>::value)> + FMT_MAP_API auto map(const T& val) -> basic_string_view<Char> { + return to_string_view(val); + } + template <typename T, typename Char = char_t<T>, + FMT_ENABLE_IF(!std::is_same<Char, char_type>::value && + !std::is_pointer<T>::value)> + FMT_MAP_API auto map(const T&) -> unformattable_char { + return {}; + } + + FMT_MAP_API auto map(void* val) -> const void* { return val; } + FMT_MAP_API auto map(const void* val) -> const void* { return val; } + FMT_MAP_API auto map(std::nullptr_t val) -> const void* { return val; } + + // Use SFINAE instead of a const T* parameter to avoid a conflict with the + // array overload. + template < + typename T, + FMT_ENABLE_IF( + std::is_pointer<T>::value || std::is_member_pointer<T>::value || + std::is_function<typename std::remove_pointer<T>::type>::value || + (std::is_array<T>::value && + !std::is_convertible<T, const char_type*>::value))> + FMT_CONSTEXPR auto map(const T&) -> unformattable_pointer { + return {}; + } + + template <typename T, std::size_t N, + FMT_ENABLE_IF(!std::is_same<T, wchar_t>::value)> + FMT_MAP_API auto map(const T (&values)[N]) -> const T (&)[N] { + return values; + } + + // Only map owning types because mapping views can be unsafe. + template <typename T, typename U = format_as_t<T>, + FMT_ENABLE_IF(std::is_arithmetic<U>::value)> + FMT_MAP_API auto map(const T& val) -> decltype(FMT_DECLTYPE_THIS map(U())) { + return map(format_as(val)); + } + + template <typename T, typename U = remove_const_t<T>> + struct formattable : bool_constant<has_const_formatter<U, Context>() || + (has_formatter<U, Context>::value && + !std::is_const<T>::value)> {}; + + template <typename T, FMT_ENABLE_IF(formattable<T>::value)> + FMT_MAP_API auto do_map(T& val) -> T& { + return val; + } + template <typename T, FMT_ENABLE_IF(!formattable<T>::value)> + FMT_MAP_API auto do_map(T&) -> unformattable { + return {}; + } + + // is_fundamental is used to allow formatters for extended FP types. + template <typename T, typename U = remove_const_t<T>, + FMT_ENABLE_IF( + (std::is_class<U>::value || std::is_enum<U>::value || + std::is_union<U>::value || std::is_fundamental<U>::value) && + !has_to_string_view<U>::value && !is_char<U>::value && + !is_named_arg<U>::value && !std::is_integral<U>::value && + !std::is_arithmetic<format_as_t<U>>::value)> + FMT_MAP_API auto map(T& val) -> decltype(FMT_DECLTYPE_THIS do_map(val)) { + return do_map(val); + } + + template <typename T, FMT_ENABLE_IF(is_named_arg<T>::value)> + FMT_MAP_API auto map(const T& named_arg) + -> decltype(FMT_DECLTYPE_THIS map(named_arg.value)) { + return map(named_arg.value); + } + + auto map(...) -> unformattable { return {}; } +}; + +// A type constant after applying arg_mapper<Context>. +template <typename T, typename Context> +using mapped_type_constant = + type_constant<decltype(arg_mapper<Context>().map(std::declval<const T&>())), + typename Context::char_type>; + +enum { packed_arg_bits = 4 }; +// Maximum number of arguments with packed types. +enum { max_packed_args = 62 / packed_arg_bits }; +enum : unsigned long long { is_unpacked_bit = 1ULL << 63 }; +enum : unsigned long long { has_named_args_bit = 1ULL << 62 }; + +template <typename It, typename T, typename Enable = void> +struct is_output_iterator : std::false_type {}; + +template <> struct is_output_iterator<appender, char> : std::true_type {}; + +template <typename It, typename T> +struct is_output_iterator< + It, T, void_t<decltype(*std::declval<It&>()++ = std::declval<T>())>> + : std::true_type {}; + +// A type-erased reference to an std::locale to avoid a heavy <locale> include. +class locale_ref { + private: + const void* locale_; // A type-erased pointer to std::locale. + + public: + constexpr locale_ref() : locale_(nullptr) {} + template <typename Locale> explicit locale_ref(const Locale& loc); + + explicit operator bool() const noexcept { return locale_ != nullptr; } + + template <typename Locale> auto get() const -> Locale; +}; + +template <typename> constexpr auto encode_types() -> unsigned long long { + return 0; +} + +template <typename Context, typename Arg, typename... Args> +constexpr auto encode_types() -> unsigned long long { + return static_cast<unsigned>(mapped_type_constant<Arg, Context>::value) | + (encode_types<Context, Args...>() << packed_arg_bits); +} + +template <typename Context, typename... T, size_t NUM_ARGS = sizeof...(T)> +constexpr unsigned long long make_descriptor() { + return NUM_ARGS <= max_packed_args ? encode_types<Context, T...>() + : is_unpacked_bit | NUM_ARGS; +} + +// This type is intentionally undefined, only used for errors. +template <typename T, typename Char> +#if FMT_CLANG_VERSION && FMT_CLANG_VERSION <= 1500 +// https://github.com/fmtlib/fmt/issues/3796 +struct type_is_unformattable_for { +}; +#else +struct type_is_unformattable_for; +#endif + +template <bool PACKED, typename Context, typename T, FMT_ENABLE_IF(PACKED)> +FMT_CONSTEXPR auto make_arg(T& val) -> value<Context> { + using arg_type = remove_cvref_t<decltype(arg_mapper<Context>().map(val))>; + + // Use enum instead of constexpr because the latter may generate code. + enum { + formattable_char = !std::is_same<arg_type, unformattable_char>::value + }; + static_assert(formattable_char, "Mixing character types is disallowed."); + + // Formatting of arbitrary pointers is disallowed. If you want to format a + // pointer cast it to `void*` or `const void*`. In particular, this forbids + // formatting of `[const] volatile char*` printed as bool by iostreams. + enum { + formattable_pointer = !std::is_same<arg_type, unformattable_pointer>::value + }; + static_assert(formattable_pointer, + "Formatting of non-void pointers is disallowed."); + + enum { formattable = !std::is_same<arg_type, unformattable>::value }; +#if defined(__cpp_if_constexpr) + if constexpr (!formattable) + type_is_unformattable_for<T, typename Context::char_type> _; +#endif + static_assert( + formattable, + "Cannot format an argument. To make type T formattable provide a " + "formatter<T> specialization: https://fmt.dev/latest/api.html#udt"); + return {arg_mapper<Context>().map(val)}; +} + +template <typename Context, typename T> +FMT_CONSTEXPR auto make_arg(T& val) -> basic_format_arg<Context> { + auto arg = basic_format_arg<Context>(); + arg.type_ = mapped_type_constant<T, Context>::value; + arg.value_ = make_arg<true, Context>(val); + return arg; +} + +template <bool PACKED, typename Context, typename T, FMT_ENABLE_IF(!PACKED)> +FMT_CONSTEXPR inline auto make_arg(T& val) -> basic_format_arg<Context> { + return make_arg<Context>(val); +} + +template <typename Context, size_t NUM_ARGS> +using arg_t = conditional_t<NUM_ARGS <= max_packed_args, value<Context>, + basic_format_arg<Context>>; + +template <typename Char, typename T, FMT_ENABLE_IF(!is_named_arg<T>::value)> +void init_named_arg(named_arg_info<Char>*, int& arg_index, int&, const T&) { + ++arg_index; +} +template <typename Char, typename T, FMT_ENABLE_IF(is_named_arg<T>::value)> +void init_named_arg(named_arg_info<Char>* named_args, int& arg_index, + int& named_arg_index, const T& arg) { + named_args[named_arg_index++] = {arg.name, arg_index++}; +} + +// An array of references to arguments. It can be implicitly converted to +// `fmt::basic_format_args` for passing into type-erased formatting functions +// such as `fmt::vformat`. +template <typename Context, size_t NUM_ARGS, size_t NUM_NAMED_ARGS, + unsigned long long DESC> +struct format_arg_store { + // args_[0].named_args points to named_args to avoid bloating format_args. + // +1 to workaround a bug in gcc 7.5 that causes duplicated-branches warning. + static constexpr size_t ARGS_ARR_SIZE = 1 + (NUM_ARGS != 0 ? NUM_ARGS : +1); + + arg_t<Context, NUM_ARGS> args[ARGS_ARR_SIZE]; + named_arg_info<typename Context::char_type> named_args[NUM_NAMED_ARGS]; + + template <typename... T> + FMT_MAP_API format_arg_store(T&... values) + : args{{named_args, NUM_NAMED_ARGS}, + make_arg<NUM_ARGS <= max_packed_args, Context>(values)...} { + using dummy = int[]; + int arg_index = 0, named_arg_index = 0; + (void)dummy{ + 0, + (init_named_arg(named_args, arg_index, named_arg_index, values), 0)...}; + } + + format_arg_store(format_arg_store&& rhs) { + args[0] = {named_args, NUM_NAMED_ARGS}; + for (size_t i = 1; i < ARGS_ARR_SIZE; ++i) args[i] = rhs.args[i]; + for (size_t i = 0; i < NUM_NAMED_ARGS; ++i) + named_args[i] = rhs.named_args[i]; + } + + format_arg_store(const format_arg_store& rhs) = delete; + format_arg_store& operator=(const format_arg_store& rhs) = delete; + format_arg_store& operator=(format_arg_store&& rhs) = delete; +}; + +// A specialization of format_arg_store without named arguments. +// It is a plain struct to reduce binary size in debug mode. +template <typename Context, size_t NUM_ARGS, unsigned long long DESC> +struct format_arg_store<Context, NUM_ARGS, 0, DESC> { + // +1 to workaround a bug in gcc 7.5 that causes duplicated-branches warning. + arg_t<Context, NUM_ARGS> args[NUM_ARGS != 0 ? NUM_ARGS : +1]; +}; + +} // namespace detail +FMT_BEGIN_EXPORT + +// A formatting argument. Context is a template parameter for the compiled API +// where output can be unbuffered. +template <typename Context> class basic_format_arg { + private: + detail::value<Context> value_; + detail::type type_; + + template <typename ContextType, typename T> + friend FMT_CONSTEXPR auto detail::make_arg(T& value) + -> basic_format_arg<ContextType>; + + friend class basic_format_args<Context>; + friend class dynamic_format_arg_store<Context>; + + using char_type = typename Context::char_type; + + template <typename, size_t, size_t, unsigned long long> + friend struct detail::format_arg_store; + + basic_format_arg(const detail::named_arg_info<char_type>* args, size_t size) + : value_(args, size) {} + + public: + class handle { + public: + explicit handle(detail::custom_value<Context> custom) : custom_(custom) {} + + void format(typename Context::parse_context_type& parse_ctx, + Context& ctx) const { + custom_.format(custom_.value, parse_ctx, ctx); + } + + private: + detail::custom_value<Context> custom_; + }; + + constexpr basic_format_arg() : type_(detail::type::none_type) {} + + constexpr explicit operator bool() const noexcept { + return type_ != detail::type::none_type; + } + + auto type() const -> detail::type { return type_; } + + auto is_integral() const -> bool { return detail::is_integral_type(type_); } + auto is_arithmetic() const -> bool { + return detail::is_arithmetic_type(type_); + } + + /** + * Visits an argument dispatching to the appropriate visit method based on + * the argument type. For example, if the argument type is `double` then + * `vis(value)` will be called with the value of type `double`. + */ + template <typename Visitor> + FMT_CONSTEXPR auto visit(Visitor&& vis) -> decltype(vis(0)) { + switch (type_) { + case detail::type::none_type: + break; + case detail::type::int_type: + return vis(value_.int_value); + case detail::type::uint_type: + return vis(value_.uint_value); + case detail::type::long_long_type: + return vis(value_.long_long_value); + case detail::type::ulong_long_type: + return vis(value_.ulong_long_value); + case detail::type::int128_type: + return vis(detail::convert_for_visit(value_.int128_value)); + case detail::type::uint128_type: + return vis(detail::convert_for_visit(value_.uint128_value)); + case detail::type::bool_type: + return vis(value_.bool_value); + case detail::type::char_type: + return vis(value_.char_value); + case detail::type::float_type: + return vis(value_.float_value); + case detail::type::double_type: + return vis(value_.double_value); + case detail::type::long_double_type: + return vis(value_.long_double_value); + case detail::type::cstring_type: + return vis(value_.string.data); + case detail::type::string_type: + using sv = basic_string_view<typename Context::char_type>; + return vis(sv(value_.string.data, value_.string.size)); + case detail::type::pointer_type: + return vis(value_.pointer); + case detail::type::custom_type: + return vis(typename basic_format_arg<Context>::handle(value_.custom)); + } + return vis(monostate()); + } + + auto format_custom(const char_type* parse_begin, + typename Context::parse_context_type& parse_ctx, + Context& ctx) -> bool { + if (type_ != detail::type::custom_type) return false; + parse_ctx.advance_to(parse_begin); + value_.custom.format(value_.custom.value, parse_ctx, ctx); + return true; + } +}; + +template <typename Visitor, typename Context> +FMT_DEPRECATED FMT_CONSTEXPR auto visit_format_arg( + Visitor&& vis, const basic_format_arg<Context>& arg) -> decltype(vis(0)) { + return arg.visit(static_cast<Visitor&&>(vis)); +} + +/** + * A view of a collection of formatting arguments. To avoid lifetime issues it + * should only be used as a parameter type in type-erased functions such as + * `vformat`: + * + * void vlog(fmt::string_view fmt, fmt::format_args args); // OK + * fmt::format_args args = fmt::make_format_args(); // Dangling reference + */ +template <typename Context> class basic_format_args { + public: + using size_type = int; + using format_arg = basic_format_arg<Context>; + + private: + // A descriptor that contains information about formatting arguments. + // If the number of arguments is less or equal to max_packed_args then + // argument types are passed in the descriptor. This reduces binary code size + // per formatting function call. + unsigned long long desc_; + union { + // If is_packed() returns true then argument values are stored in values_; + // otherwise they are stored in args_. This is done to improve cache + // locality and reduce compiled code size since storing larger objects + // may require more code (at least on x86-64) even if the same amount of + // data is actually copied to stack. It saves ~10% on the bloat test. + const detail::value<Context>* values_; + const format_arg* args_; + }; + + constexpr auto is_packed() const -> bool { + return (desc_ & detail::is_unpacked_bit) == 0; + } + constexpr auto has_named_args() const -> bool { + return (desc_ & detail::has_named_args_bit) != 0; + } + + FMT_CONSTEXPR auto type(int index) const -> detail::type { + int shift = index * detail::packed_arg_bits; + unsigned int mask = (1 << detail::packed_arg_bits) - 1; + return static_cast<detail::type>((desc_ >> shift) & mask); + } + + public: + constexpr basic_format_args() : desc_(0), args_(nullptr) {} + + /// Constructs a `basic_format_args` object from `format_arg_store`. + template <size_t NUM_ARGS, size_t NUM_NAMED_ARGS, unsigned long long DESC, + FMT_ENABLE_IF(NUM_ARGS <= detail::max_packed_args)> + constexpr FMT_ALWAYS_INLINE basic_format_args( + const detail::format_arg_store<Context, NUM_ARGS, NUM_NAMED_ARGS, DESC>& + store) + : desc_(DESC), values_(store.args + (NUM_NAMED_ARGS != 0 ? 1 : 0)) {} + + template <size_t NUM_ARGS, size_t NUM_NAMED_ARGS, unsigned long long DESC, + FMT_ENABLE_IF(NUM_ARGS > detail::max_packed_args)> + constexpr basic_format_args( + const detail::format_arg_store<Context, NUM_ARGS, NUM_NAMED_ARGS, DESC>& + store) + : desc_(DESC), args_(store.args + (NUM_NAMED_ARGS != 0 ? 1 : 0)) {} + + /// Constructs a `basic_format_args` object from `dynamic_format_arg_store`. + constexpr basic_format_args(const dynamic_format_arg_store<Context>& store) + : desc_(store.get_types()), args_(store.data()) {} + + /// Constructs a `basic_format_args` object from a dynamic list of arguments. + constexpr basic_format_args(const format_arg* args, int count) + : desc_(detail::is_unpacked_bit | detail::to_unsigned(count)), + args_(args) {} + + /// Returns the argument with the specified id. + FMT_CONSTEXPR auto get(int id) const -> format_arg { + format_arg arg; + if (!is_packed()) { + if (id < max_size()) arg = args_[id]; + return arg; + } + if (static_cast<unsigned>(id) >= detail::max_packed_args) return arg; + arg.type_ = type(id); + if (arg.type_ == detail::type::none_type) return arg; + arg.value_ = values_[id]; + return arg; + } + + template <typename Char> + auto get(basic_string_view<Char> name) const -> format_arg { + int id = get_id(name); + return id >= 0 ? get(id) : format_arg(); + } + + template <typename Char> + FMT_CONSTEXPR auto get_id(basic_string_view<Char> name) const -> int { + if (!has_named_args()) return -1; + const auto& named_args = + (is_packed() ? values_[-1] : args_[-1].value_).named_args; + for (size_t i = 0; i < named_args.size; ++i) { + if (named_args.data[i].name == name) return named_args.data[i].id; + } + return -1; + } + + auto max_size() const -> int { + unsigned long long max_packed = detail::max_packed_args; + return static_cast<int>(is_packed() ? max_packed + : desc_ & ~detail::is_unpacked_bit); + } +}; + +// A formatting context. +class context { + private: + appender out_; + basic_format_args<context> args_; + detail::locale_ref loc_; + + public: + /// The character type for the output. + using char_type = char; + + using iterator = appender; + using format_arg = basic_format_arg<context>; + using parse_context_type = basic_format_parse_context<char>; + template <typename T> using formatter_type = formatter<T, char>; + + /// Constructs a `basic_format_context` object. References to the arguments + /// are stored in the object so make sure they have appropriate lifetimes. + FMT_CONSTEXPR context(iterator out, basic_format_args<context> ctx_args, + detail::locale_ref loc = {}) + : out_(out), args_(ctx_args), loc_(loc) {} + context(context&&) = default; + context(const context&) = delete; + void operator=(const context&) = delete; + + FMT_CONSTEXPR auto arg(int id) const -> format_arg { return args_.get(id); } + auto arg(string_view name) -> format_arg { return args_.get(name); } + FMT_CONSTEXPR auto arg_id(string_view name) -> int { + return args_.get_id(name); + } + auto args() const -> const basic_format_args<context>& { return args_; } + + // Returns an iterator to the beginning of the output range. + FMT_CONSTEXPR auto out() -> iterator { return out_; } + + // Advances the begin iterator to `it`. + void advance_to(iterator) {} + + FMT_CONSTEXPR auto locale() -> detail::locale_ref { return loc_; } +}; + +template <typename OutputIt, typename Char> class generic_context; + +// Longer aliases for C++20 compatibility. +template <typename OutputIt, typename Char> +using basic_format_context = + conditional_t<std::is_same<OutputIt, appender>::value, context, + generic_context<OutputIt, Char>>; +using format_context = context; + +template <typename Char> +using buffered_context = basic_format_context<basic_appender<Char>, Char>; + +template <typename T, typename Char = char> +using is_formattable = bool_constant<!std::is_base_of< + detail::unformattable, decltype(detail::arg_mapper<buffered_context<Char>>() + .map(std::declval<T&>()))>::value>; + +#if FMT_USE_CONCEPTS +template <typename T, typename Char = char> +concept formattable = is_formattable<remove_reference_t<T>, Char>::value; +#endif + +/** + * Constructs an object that stores references to arguments and can be + * implicitly converted to `format_args`. `Context` can be omitted in which case + * it defaults to `format_context`. See `arg` for lifetime considerations. + */ +// Take arguments by lvalue references to avoid some lifetime issues, e.g. +// auto args = make_format_args(std::string()); +template <typename Context = format_context, typename... T, + size_t NUM_ARGS = sizeof...(T), + size_t NUM_NAMED_ARGS = detail::count_named_args<T...>(), + unsigned long long DESC = detail::make_descriptor<Context, T...>(), + FMT_ENABLE_IF(NUM_NAMED_ARGS == 0)> +constexpr FMT_ALWAYS_INLINE auto make_format_args(T&... args) + -> detail::format_arg_store<Context, NUM_ARGS, 0, DESC> { + return {{detail::make_arg<NUM_ARGS <= detail::max_packed_args, Context>( + args)...}}; +} + +#ifndef FMT_DOC +template <typename Context = format_context, typename... T, + size_t NUM_NAMED_ARGS = detail::count_named_args<T...>(), + unsigned long long DESC = + detail::make_descriptor<Context, T...>() | + static_cast<unsigned long long>(detail::has_named_args_bit), + FMT_ENABLE_IF(NUM_NAMED_ARGS != 0)> +constexpr auto make_format_args(T&... args) + -> detail::format_arg_store<Context, sizeof...(T), NUM_NAMED_ARGS, DESC> { + return {args...}; +} +#endif + +/** + * Returns a named argument to be used in a formatting function. + * It should only be used in a call to a formatting function or + * `dynamic_format_arg_store::push_back`. + * + * **Example**: + * + * fmt::print("The answer is {answer}.", fmt::arg("answer", 42)); + */ +template <typename Char, typename T> +inline auto arg(const Char* name, const T& arg) -> detail::named_arg<Char, T> { + static_assert(!detail::is_named_arg<T>(), "nested named arguments"); + return {name, arg}; +} +FMT_END_EXPORT + +/// An alias for `basic_format_args<format_context>`. +// A separate type would result in shorter symbols but break ABI compatibility +// between clang and gcc on ARM (#1919). +FMT_EXPORT using format_args = basic_format_args<format_context>; + +// We cannot use enum classes as bit fields because of a gcc bug, so we put them +// in namespaces instead (https://gcc.gnu.org/bugzilla/show_bug.cgi?id=61414). +// Additionally, if an underlying type is specified, older gcc incorrectly warns +// that the type is too small. Both bugs are fixed in gcc 9.3. +#if FMT_GCC_VERSION && FMT_GCC_VERSION < 903 +# define FMT_ENUM_UNDERLYING_TYPE(type) +#else +# define FMT_ENUM_UNDERLYING_TYPE(type) : type +#endif +namespace align { +enum type FMT_ENUM_UNDERLYING_TYPE(unsigned char){none, left, right, center, + numeric}; +} +using align_t = align::type; +namespace sign { +enum type FMT_ENUM_UNDERLYING_TYPE(unsigned char){none, minus, plus, space}; +} +using sign_t = sign::type; + +namespace detail { + +template <typename Char> +using unsigned_char = typename conditional_t<std::is_integral<Char>::value, + std::make_unsigned<Char>, + type_identity<unsigned>>::type; + +// Character (code unit) type is erased to prevent template bloat. +struct fill_t { + private: + enum { max_size = 4 }; + char data_[max_size] = {' '}; + unsigned char size_ = 1; + + public: + template <typename Char> + FMT_CONSTEXPR void operator=(basic_string_view<Char> s) { + auto size = s.size(); + size_ = static_cast<unsigned char>(size); + if (size == 1) { + unsigned uchar = static_cast<unsigned_char<Char>>(s[0]); + data_[0] = static_cast<char>(uchar); + data_[1] = static_cast<char>(uchar >> 8); + return; + } + FMT_ASSERT(size <= max_size, "invalid fill"); + for (size_t i = 0; i < size; ++i) data_[i] = static_cast<char>(s[i]); + } + + FMT_CONSTEXPR void operator=(char c) { + data_[0] = c; + size_ = 1; + } + + constexpr auto size() const -> size_t { return size_; } + + template <typename Char> constexpr auto get() const -> Char { + using uchar = unsigned char; + return static_cast<Char>(static_cast<uchar>(data_[0]) | + (static_cast<uchar>(data_[1]) << 8)); + } + + template <typename Char, FMT_ENABLE_IF(std::is_same<Char, char>::value)> + constexpr auto data() const -> const Char* { + return data_; + } + template <typename Char, FMT_ENABLE_IF(!std::is_same<Char, char>::value)> + constexpr auto data() const -> const Char* { + return nullptr; + } +}; +} // namespace detail + +enum class presentation_type : unsigned char { + // Common specifiers: + none = 0, + debug = 1, // '?' + string = 2, // 's' (string, bool) + + // Integral, bool and character specifiers: + dec = 3, // 'd' + hex, // 'x' or 'X' + oct, // 'o' + bin, // 'b' or 'B' + chr, // 'c' + + // String and pointer specifiers: + pointer = 3, // 'p' + + // Floating-point specifiers: + exp = 1, // 'e' or 'E' (1 since there is no FP debug presentation) + fixed, // 'f' or 'F' + general, // 'g' or 'G' + hexfloat // 'a' or 'A' +}; + +// Format specifiers for built-in and string types. +struct format_specs { + int width; + int precision; + presentation_type type; + align_t align : 4; + sign_t sign : 3; + bool upper : 1; // An uppercase version e.g. 'X' for 'x'. + bool alt : 1; // Alternate form ('#'). + bool localized : 1; + detail::fill_t fill; + + constexpr format_specs() + : width(0), + precision(-1), + type(presentation_type::none), + align(align::none), + sign(sign::none), + upper(false), + alt(false), + localized(false) {} +}; + +namespace detail { + +enum class arg_id_kind { none, index, name }; + +// An argument reference. +template <typename Char> struct arg_ref { + FMT_CONSTEXPR arg_ref() : kind(arg_id_kind::none), val() {} + + FMT_CONSTEXPR explicit arg_ref(int index) + : kind(arg_id_kind::index), val(index) {} + FMT_CONSTEXPR explicit arg_ref(basic_string_view<Char> name) + : kind(arg_id_kind::name), val(name) {} + + FMT_CONSTEXPR auto operator=(int idx) -> arg_ref& { + kind = arg_id_kind::index; + val.index = idx; + return *this; + } + + arg_id_kind kind; + union value { + FMT_CONSTEXPR value(int idx = 0) : index(idx) {} + FMT_CONSTEXPR value(basic_string_view<Char> n) : name(n) {} + + int index; + basic_string_view<Char> name; + } val; +}; + +// Format specifiers with width and precision resolved at formatting rather +// than parsing time to allow reusing the same parsed specifiers with +// different sets of arguments (precompilation of format strings). +template <typename Char = char> struct dynamic_format_specs : format_specs { + arg_ref<Char> width_ref; + arg_ref<Char> precision_ref; +}; + +// Converts a character to ASCII. Returns '\0' on conversion failure. +template <typename Char, FMT_ENABLE_IF(std::is_integral<Char>::value)> +constexpr auto to_ascii(Char c) -> char { + return c <= 0xff ? static_cast<char>(c) : '\0'; +} + +// Returns the number of code units in a code point or 1 on error. +template <typename Char> +FMT_CONSTEXPR auto code_point_length(const Char* begin) -> int { + if (const_check(sizeof(Char) != 1)) return 1; + auto c = static_cast<unsigned char>(*begin); + return static_cast<int>((0x3a55000000000000ull >> (2 * (c >> 3))) & 0x3) + 1; +} + +// Return the result via the out param to workaround gcc bug 77539. +template <bool IS_CONSTEXPR, typename T, typename Ptr = const T*> +FMT_CONSTEXPR auto find(Ptr first, Ptr last, T value, Ptr& out) -> bool { + for (out = first; out != last; ++out) { + if (*out == value) return true; + } + return false; +} + +template <> +inline auto find<false, char>(const char* first, const char* last, char value, + const char*& out) -> bool { + out = + static_cast<const char*>(memchr(first, value, to_unsigned(last - first))); + return out != nullptr; +} + +// Parses the range [begin, end) as an unsigned integer. This function assumes +// that the range is non-empty and the first character is a digit. +template <typename Char> +FMT_CONSTEXPR auto parse_nonnegative_int(const Char*& begin, const Char* end, + int error_value) noexcept -> int { + FMT_ASSERT(begin != end && '0' <= *begin && *begin <= '9', ""); + unsigned value = 0, prev = 0; + auto p = begin; + do { + prev = value; + value = value * 10 + unsigned(*p - '0'); + ++p; + } while (p != end && '0' <= *p && *p <= '9'); + auto num_digits = p - begin; + begin = p; + int digits10 = static_cast<int>(sizeof(int) * CHAR_BIT * 3 / 10); + if (num_digits <= digits10) return static_cast<int>(value); + // Check for overflow. + unsigned max = INT_MAX; + return num_digits == digits10 + 1 && + prev * 10ull + unsigned(p[-1] - '0') <= max + ? static_cast<int>(value) + : error_value; +} + +FMT_CONSTEXPR inline auto parse_align(char c) -> align_t { + switch (c) { + case '<': + return align::left; + case '>': + return align::right; + case '^': + return align::center; + } + return align::none; +} + +template <typename Char> constexpr auto is_name_start(Char c) -> bool { + return ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z') || c == '_'; +} + +template <typename Char, typename Handler> +FMT_CONSTEXPR auto do_parse_arg_id(const Char* begin, const Char* end, + Handler&& handler) -> const Char* { + Char c = *begin; + if (c >= '0' && c <= '9') { + int index = 0; + if (c != '0') + index = parse_nonnegative_int(begin, end, INT_MAX); + else + ++begin; + if (begin == end || (*begin != '}' && *begin != ':')) + report_error("invalid format string"); + else + handler.on_index(index); + return begin; + } + if (!is_name_start(c)) { + report_error("invalid format string"); + return begin; + } + auto it = begin; + do { + ++it; + } while (it != end && (is_name_start(*it) || ('0' <= *it && *it <= '9'))); + handler.on_name({begin, to_unsigned(it - begin)}); + return it; +} + +template <typename Char, typename Handler> +FMT_CONSTEXPR auto parse_arg_id(const Char* begin, const Char* end, + Handler&& handler) -> const Char* { + FMT_ASSERT(begin != end, ""); + Char c = *begin; + if (c != '}' && c != ':') return do_parse_arg_id(begin, end, handler); + handler.on_auto(); + return begin; +} + +template <typename Char> struct dynamic_spec_id_handler { + basic_format_parse_context<Char>& ctx; + arg_ref<Char>& ref; + + FMT_CONSTEXPR void on_auto() { + int id = ctx.next_arg_id(); + ref = arg_ref<Char>(id); + ctx.check_dynamic_spec(id); + } + FMT_CONSTEXPR void on_index(int id) { + ref = arg_ref<Char>(id); + ctx.check_arg_id(id); + ctx.check_dynamic_spec(id); + } + FMT_CONSTEXPR void on_name(basic_string_view<Char> id) { + ref = arg_ref<Char>(id); + ctx.check_arg_id(id); + } +}; + +// Parses [integer | "{" [arg_id] "}"]. +template <typename Char> +FMT_CONSTEXPR auto parse_dynamic_spec(const Char* begin, const Char* end, + int& value, arg_ref<Char>& ref, + basic_format_parse_context<Char>& ctx) + -> const Char* { + FMT_ASSERT(begin != end, ""); + if ('0' <= *begin && *begin <= '9') { + int val = parse_nonnegative_int(begin, end, -1); + if (val != -1) + value = val; + else + report_error("number is too big"); + } else if (*begin == '{') { + ++begin; + auto handler = dynamic_spec_id_handler<Char>{ctx, ref}; + if (begin != end) begin = parse_arg_id(begin, end, handler); + if (begin != end && *begin == '}') return ++begin; + report_error("invalid format string"); + } + return begin; +} + +template <typename Char> +FMT_CONSTEXPR auto parse_precision(const Char* begin, const Char* end, + int& value, arg_ref<Char>& ref, + basic_format_parse_context<Char>& ctx) + -> const Char* { + ++begin; + if (begin == end || *begin == '}') { + report_error("invalid precision"); + return begin; + } + return parse_dynamic_spec(begin, end, value, ref, ctx); +} + +enum class state { start, align, sign, hash, zero, width, precision, locale }; + +// Parses standard format specifiers. +template <typename Char> +FMT_CONSTEXPR auto parse_format_specs(const Char* begin, const Char* end, + dynamic_format_specs<Char>& specs, + basic_format_parse_context<Char>& ctx, + type arg_type) -> const Char* { + auto c = '\0'; + if (end - begin > 1) { + auto next = to_ascii(begin[1]); + c = parse_align(next) == align::none ? to_ascii(*begin) : '\0'; + } else { + if (begin == end) return begin; + c = to_ascii(*begin); + } + + struct { + state current_state = state::start; + FMT_CONSTEXPR void operator()(state s, bool valid = true) { + if (current_state >= s || !valid) + report_error("invalid format specifier"); + current_state = s; + } + } enter_state; + + using pres = presentation_type; + constexpr auto integral_set = sint_set | uint_set | bool_set | char_set; + struct { + const Char*& begin; + dynamic_format_specs<Char>& specs; + type arg_type; + + FMT_CONSTEXPR auto operator()(pres pres_type, int set) -> const Char* { + if (!in(arg_type, set)) { + if (arg_type == type::none_type) return begin; + report_error("invalid format specifier"); + } + specs.type = pres_type; + return begin + 1; + } + } parse_presentation_type{begin, specs, arg_type}; + + for (;;) { + switch (c) { + case '<': + case '>': + case '^': + enter_state(state::align); + specs.align = parse_align(c); + ++begin; + break; + case '+': + case '-': + case ' ': + if (arg_type == type::none_type) return begin; + enter_state(state::sign, in(arg_type, sint_set | float_set)); + switch (c) { + case '+': + specs.sign = sign::plus; + break; + case '-': + specs.sign = sign::minus; + break; + case ' ': + specs.sign = sign::space; + break; + } + ++begin; + break; + case '#': + if (arg_type == type::none_type) return begin; + enter_state(state::hash, is_arithmetic_type(arg_type)); + specs.alt = true; + ++begin; + break; + case '0': + enter_state(state::zero); + if (!is_arithmetic_type(arg_type)) { + if (arg_type == type::none_type) return begin; + report_error("format specifier requires numeric argument"); + } + if (specs.align == align::none) { + // Ignore 0 if align is specified for compatibility with std::format. + specs.align = align::numeric; + specs.fill = '0'; + } + ++begin; + break; + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + case '{': + enter_state(state::width); + begin = parse_dynamic_spec(begin, end, specs.width, specs.width_ref, ctx); + break; + case '.': + if (arg_type == type::none_type) return begin; + enter_state(state::precision, + in(arg_type, float_set | string_set | cstring_set)); + begin = parse_precision(begin, end, specs.precision, specs.precision_ref, + ctx); + break; + case 'L': + if (arg_type == type::none_type) return begin; + enter_state(state::locale, is_arithmetic_type(arg_type)); + specs.localized = true; + ++begin; + break; + case 'd': + return parse_presentation_type(pres::dec, integral_set); + case 'X': + specs.upper = true; + FMT_FALLTHROUGH; + case 'x': + return parse_presentation_type(pres::hex, integral_set); + case 'o': + return parse_presentation_type(pres::oct, integral_set); + case 'B': + specs.upper = true; + FMT_FALLTHROUGH; + case 'b': + return parse_presentation_type(pres::bin, integral_set); + case 'E': + specs.upper = true; + FMT_FALLTHROUGH; + case 'e': + return parse_presentation_type(pres::exp, float_set); + case 'F': + specs.upper = true; + FMT_FALLTHROUGH; + case 'f': + return parse_presentation_type(pres::fixed, float_set); + case 'G': + specs.upper = true; + FMT_FALLTHROUGH; + case 'g': + return parse_presentation_type(pres::general, float_set); + case 'A': + specs.upper = true; + FMT_FALLTHROUGH; + case 'a': + return parse_presentation_type(pres::hexfloat, float_set); + case 'c': + if (arg_type == type::bool_type) report_error("invalid format specifier"); + return parse_presentation_type(pres::chr, integral_set); + case 's': + return parse_presentation_type(pres::string, + bool_set | string_set | cstring_set); + case 'p': + return parse_presentation_type(pres::pointer, pointer_set | cstring_set); + case '?': + return parse_presentation_type(pres::debug, + char_set | string_set | cstring_set); + case '}': + return begin; + default: { + if (*begin == '}') return begin; + // Parse fill and alignment. + auto fill_end = begin + code_point_length(begin); + if (end - fill_end <= 0) { + report_error("invalid format specifier"); + return begin; + } + if (*begin == '{') { + report_error("invalid fill character '{'"); + return begin; + } + auto align = parse_align(to_ascii(*fill_end)); + enter_state(state::align, align != align::none); + specs.fill = + basic_string_view<Char>(begin, to_unsigned(fill_end - begin)); + specs.align = align; + begin = fill_end + 1; + } + } + if (begin == end) return begin; + c = to_ascii(*begin); + } +} + +template <typename Char, typename Handler> +FMT_CONSTEXPR auto parse_replacement_field(const Char* begin, const Char* end, + Handler&& handler) -> const Char* { + struct id_adapter { + Handler& handler; + int arg_id; + + FMT_CONSTEXPR void on_auto() { arg_id = handler.on_arg_id(); } + FMT_CONSTEXPR void on_index(int id) { arg_id = handler.on_arg_id(id); } + FMT_CONSTEXPR void on_name(basic_string_view<Char> id) { + arg_id = handler.on_arg_id(id); + } + }; + + ++begin; + if (begin == end) return handler.on_error("invalid format string"), end; + if (*begin == '}') { + handler.on_replacement_field(handler.on_arg_id(), begin); + } else if (*begin == '{') { + handler.on_text(begin, begin + 1); + } else { + auto adapter = id_adapter{handler, 0}; + begin = parse_arg_id(begin, end, adapter); + Char c = begin != end ? *begin : Char(); + if (c == '}') { + handler.on_replacement_field(adapter.arg_id, begin); + } else if (c == ':') { + begin = handler.on_format_specs(adapter.arg_id, begin + 1, end); + if (begin == end || *begin != '}') + return handler.on_error("unknown format specifier"), end; + } else { + return handler.on_error("missing '}' in format string"), end; + } + } + return begin + 1; +} + +template <bool IS_CONSTEXPR, typename Char, typename Handler> +FMT_CONSTEXPR void parse_format_string(basic_string_view<Char> format_str, + Handler&& handler) { + auto begin = format_str.data(); + auto end = begin + format_str.size(); + if (end - begin < 32) { + // Use a simple loop instead of memchr for small strings. + const Char* p = begin; + while (p != end) { + auto c = *p++; + if (c == '{') { + handler.on_text(begin, p - 1); + begin = p = parse_replacement_field(p - 1, end, handler); + } else if (c == '}') { + if (p == end || *p != '}') + return handler.on_error("unmatched '}' in format string"); + handler.on_text(begin, p); + begin = ++p; + } + } + handler.on_text(begin, end); + return; + } + struct writer { + FMT_CONSTEXPR void operator()(const Char* from, const Char* to) { + if (from == to) return; + for (;;) { + const Char* p = nullptr; + if (!find<IS_CONSTEXPR>(from, to, Char('}'), p)) + return handler_.on_text(from, to); + ++p; + if (p == to || *p != '}') + return handler_.on_error("unmatched '}' in format string"); + handler_.on_text(from, p); + from = p + 1; + } + } + Handler& handler_; + } write = {handler}; + while (begin != end) { + // Doing two passes with memchr (one for '{' and another for '}') is up to + // 2.5x faster than the naive one-pass implementation on big format strings. + const Char* p = begin; + if (*begin != '{' && !find<IS_CONSTEXPR>(begin + 1, end, Char('{'), p)) + return write(begin, end); + write(begin, p); + begin = parse_replacement_field(p, end, handler); + } +} + +template <typename T, bool = is_named_arg<T>::value> struct strip_named_arg { + using type = T; +}; +template <typename T> struct strip_named_arg<T, true> { + using type = remove_cvref_t<decltype(T::value)>; +}; + +template <typename T, typename ParseContext> +FMT_VISIBILITY("hidden") // Suppress an ld warning on macOS (#3769). +FMT_CONSTEXPR auto parse_format_specs(ParseContext& ctx) + -> decltype(ctx.begin()) { + using char_type = typename ParseContext::char_type; + using context = buffered_context<char_type>; + using mapped_type = conditional_t< + mapped_type_constant<T, context>::value != type::custom_type, + decltype(arg_mapper<context>().map(std::declval<const T&>())), + typename strip_named_arg<T>::type>; +#if defined(__cpp_if_constexpr) + if constexpr (std::is_default_constructible< + formatter<mapped_type, char_type>>::value) { + return formatter<mapped_type, char_type>().parse(ctx); + } else { + type_is_unformattable_for<T, char_type> _; + return ctx.begin(); + } +#else + return formatter<mapped_type, char_type>().parse(ctx); +#endif +} + +// Checks char specs and returns true iff the presentation type is char-like. +FMT_CONSTEXPR inline auto check_char_specs(const format_specs& specs) -> bool { + if (specs.type != presentation_type::none && + specs.type != presentation_type::chr && + specs.type != presentation_type::debug) { + return false; + } + if (specs.align == align::numeric || specs.sign != sign::none || specs.alt) + report_error("invalid format specifier for char"); + return true; +} + +#if FMT_USE_NONTYPE_TEMPLATE_ARGS +template <int N, typename T, typename... Args, typename Char> +constexpr auto get_arg_index_by_name(basic_string_view<Char> name) -> int { + if constexpr (is_statically_named_arg<T>()) { + if (name == T::name) return N; + } + if constexpr (sizeof...(Args) > 0) + return get_arg_index_by_name<N + 1, Args...>(name); + (void)name; // Workaround an MSVC bug about "unused" parameter. + return -1; +} +#endif + +template <typename... Args, typename Char> +FMT_CONSTEXPR auto get_arg_index_by_name(basic_string_view<Char> name) -> int { +#if FMT_USE_NONTYPE_TEMPLATE_ARGS + if constexpr (sizeof...(Args) > 0) + return get_arg_index_by_name<0, Args...>(name); +#endif + (void)name; + return -1; +} + +template <typename Char, typename... Args> class format_string_checker { + private: + using parse_context_type = compile_parse_context<Char>; + static constexpr int num_args = sizeof...(Args); + + // Format specifier parsing function. + // In the future basic_format_parse_context will replace compile_parse_context + // here and will use is_constant_evaluated and downcasting to access the data + // needed for compile-time checks: https://godbolt.org/z/GvWzcTjh1. + using parse_func = const Char* (*)(parse_context_type&); + + type types_[num_args > 0 ? static_cast<size_t>(num_args) : 1]; + parse_context_type context_; + parse_func parse_funcs_[num_args > 0 ? static_cast<size_t>(num_args) : 1]; + + public: + explicit FMT_CONSTEXPR format_string_checker(basic_string_view<Char> fmt) + : types_{mapped_type_constant<Args, buffered_context<Char>>::value...}, + context_(fmt, num_args, types_), + parse_funcs_{&parse_format_specs<Args, parse_context_type>...} {} + + FMT_CONSTEXPR void on_text(const Char*, const Char*) {} + + FMT_CONSTEXPR auto on_arg_id() -> int { return context_.next_arg_id(); } + FMT_CONSTEXPR auto on_arg_id(int id) -> int { + return context_.check_arg_id(id), id; + } + FMT_CONSTEXPR auto on_arg_id(basic_string_view<Char> id) -> int { +#if FMT_USE_NONTYPE_TEMPLATE_ARGS + auto index = get_arg_index_by_name<Args...>(id); + if (index < 0) on_error("named argument is not found"); + return index; +#else + (void)id; + on_error("compile-time checks for named arguments require C++20 support"); + return 0; +#endif + } + + FMT_CONSTEXPR void on_replacement_field(int id, const Char* begin) { + on_format_specs(id, begin, begin); // Call parse() on empty specs. + } + + FMT_CONSTEXPR auto on_format_specs(int id, const Char* begin, const Char*) + -> const Char* { + context_.advance_to(begin); + // id >= 0 check is a workaround for gcc 10 bug (#2065). + return id >= 0 && id < num_args ? parse_funcs_[id](context_) : begin; + } + + FMT_NORETURN FMT_CONSTEXPR void on_error(const char* message) { + report_error(message); + } +}; + +// A base class for compile-time strings. +struct compile_string {}; + +template <typename S> +using is_compile_string = std::is_base_of<compile_string, S>; + +// Reports a compile-time error if S is not a valid format string. +template <typename..., typename S, FMT_ENABLE_IF(!is_compile_string<S>::value)> +FMT_ALWAYS_INLINE void check_format_string(const S&) { +#ifdef FMT_ENFORCE_COMPILE_STRING + static_assert(is_compile_string<S>::value, + "FMT_ENFORCE_COMPILE_STRING requires all format strings to use " + "FMT_STRING."); +#endif +} +template <typename... Args, typename S, + FMT_ENABLE_IF(is_compile_string<S>::value)> +void check_format_string(S format_str) { + using char_t = typename S::char_type; + FMT_CONSTEXPR auto s = basic_string_view<char_t>(format_str); + using checker = format_string_checker<char_t, remove_cvref_t<Args>...>; + FMT_CONSTEXPR bool error = (parse_format_string<true>(s, checker(s)), true); + ignore_unused(error); +} + +// Report truncation to prevent silent data loss. +inline void report_truncation(bool truncated) { + if (truncated) report_error("output is truncated"); +} + +// Use vformat_args and avoid type_identity to keep symbols short and workaround +// a GCC <= 4.8 bug. +template <typename Char = char> struct vformat_args { + using type = basic_format_args<buffered_context<Char>>; +}; +template <> struct vformat_args<char> { + using type = format_args; +}; + +template <typename Char> +void vformat_to(buffer<Char>& buf, basic_string_view<Char> fmt, + typename vformat_args<Char>::type args, locale_ref loc = {}); + +FMT_API void vprint_mojibake(FILE*, string_view, format_args, bool = false); +#ifndef _WIN32 +inline void vprint_mojibake(FILE*, string_view, format_args, bool) {} +#endif + +template <typename T, typename Char, type TYPE> struct native_formatter { + private: + dynamic_format_specs<Char> specs_; + + public: + using nonlocking = void; + + template <typename ParseContext> + FMT_CONSTEXPR auto parse(ParseContext& ctx) -> const Char* { + if (ctx.begin() == ctx.end() || *ctx.begin() == '}') return ctx.begin(); + auto end = parse_format_specs(ctx.begin(), ctx.end(), specs_, ctx, TYPE); + if (const_check(TYPE == type::char_type)) check_char_specs(specs_); + return end; + } + + template <type U = TYPE, + FMT_ENABLE_IF(U == type::string_type || U == type::cstring_type || + U == type::char_type)> + FMT_CONSTEXPR void set_debug_format(bool set = true) { + specs_.type = set ? presentation_type::debug : presentation_type::none; + } + + template <typename FormatContext> + FMT_CONSTEXPR auto format(const T& val, FormatContext& ctx) const + -> decltype(ctx.out()); +}; +} // namespace detail + +FMT_BEGIN_EXPORT + +// A formatter specialization for natively supported types. +template <typename T, typename Char> +struct formatter<T, Char, + enable_if_t<detail::type_constant<T, Char>::value != + detail::type::custom_type>> + : detail::native_formatter<T, Char, detail::type_constant<T, Char>::value> { +}; + +template <typename Char = char> struct runtime_format_string { + basic_string_view<Char> str; +}; + +/// A compile-time format string. +template <typename Char, typename... Args> class basic_format_string { + private: + basic_string_view<Char> str_; + + public: + template < + typename S, + FMT_ENABLE_IF( + std::is_convertible<const S&, basic_string_view<Char>>::value || + (detail::is_compile_string<S>::value && + std::is_constructible<basic_string_view<Char>, const S&>::value))> + FMT_CONSTEVAL FMT_ALWAYS_INLINE basic_format_string(const S& s) : str_(s) { + static_assert( + detail::count< + (std::is_base_of<detail::view, remove_reference_t<Args>>::value && + std::is_reference<Args>::value)...>() == 0, + "passing views as lvalues is disallowed"); +#if FMT_USE_CONSTEVAL + if constexpr (detail::count_named_args<Args...>() == + detail::count_statically_named_args<Args...>()) { + using checker = + detail::format_string_checker<Char, remove_cvref_t<Args>...>; + detail::parse_format_string<true>(str_, checker(s)); + } +#else + detail::check_format_string<Args...>(s); +#endif + } + basic_format_string(runtime_format_string<Char> fmt) : str_(fmt.str) {} + + FMT_ALWAYS_INLINE operator basic_string_view<Char>() const { return str_; } + auto get() const -> basic_string_view<Char> { return str_; } +}; + +#if FMT_GCC_VERSION && FMT_GCC_VERSION < 409 +// Workaround broken conversion on older gcc. +template <typename...> using format_string = string_view; +inline auto runtime(string_view s) -> string_view { return s; } +#else +template <typename... Args> +using format_string = basic_format_string<char, type_identity_t<Args>...>; +/** + * Creates a runtime format string. + * + * **Example**: + * + * // Check format string at runtime instead of compile-time. + * fmt::print(fmt::runtime("{:d}"), "I am not a number"); + */ +inline auto runtime(string_view s) -> runtime_format_string<> { return {{s}}; } +#endif + +/// Formats a string and writes the output to `out`. +template <typename OutputIt, + FMT_ENABLE_IF(detail::is_output_iterator<remove_cvref_t<OutputIt>, + char>::value)> +auto vformat_to(OutputIt&& out, string_view fmt, format_args args) + -> remove_cvref_t<OutputIt> { + auto&& buf = detail::get_buffer<char>(out); + detail::vformat_to(buf, fmt, args, {}); + return detail::get_iterator(buf, out); +} + +/** + * Formats `args` according to specifications in `fmt`, writes the result to + * the output iterator `out` and returns the iterator past the end of the output + * range. `format_to` does not append a terminating null character. + * + * **Example**: + * + * auto out = std::vector<char>(); + * fmt::format_to(std::back_inserter(out), "{}", 42); + */ +template <typename OutputIt, typename... T, + FMT_ENABLE_IF(detail::is_output_iterator<remove_cvref_t<OutputIt>, + char>::value)> +FMT_INLINE auto format_to(OutputIt&& out, format_string<T...> fmt, T&&... args) + -> remove_cvref_t<OutputIt> { + return vformat_to(FMT_FWD(out), fmt, fmt::make_format_args(args...)); +} + +template <typename OutputIt> struct format_to_n_result { + /// Iterator past the end of the output range. + OutputIt out; + /// Total (not truncated) output size. + size_t size; +}; + +template <typename OutputIt, typename... T, + FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, char>::value)> +auto vformat_to_n(OutputIt out, size_t n, string_view fmt, format_args args) + -> format_to_n_result<OutputIt> { + using traits = detail::fixed_buffer_traits; + auto buf = detail::iterator_buffer<OutputIt, char, traits>(out, n); + detail::vformat_to(buf, fmt, args, {}); + return {buf.out(), buf.count()}; +} + +/** + * Formats `args` according to specifications in `fmt`, writes up to `n` + * characters of the result to the output iterator `out` and returns the total + * (not truncated) output size and the iterator past the end of the output + * range. `format_to_n` does not append a terminating null character. + */ +template <typename OutputIt, typename... T, + FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, char>::value)> +FMT_INLINE auto format_to_n(OutputIt out, size_t n, format_string<T...> fmt, + T&&... args) -> format_to_n_result<OutputIt> { + return vformat_to_n(out, n, fmt, fmt::make_format_args(args...)); +} + +template <typename OutputIt, typename Sentinel = OutputIt> +struct format_to_result { + /// Iterator pointing to just after the last successful write in the range. + OutputIt out; + /// Specifies if the output was truncated. + bool truncated; + + FMT_CONSTEXPR operator OutputIt&() & { + detail::report_truncation(truncated); + return out; + } + FMT_CONSTEXPR operator const OutputIt&() const& { + detail::report_truncation(truncated); + return out; + } + FMT_CONSTEXPR operator OutputIt&&() && { + detail::report_truncation(truncated); + return static_cast<OutputIt&&>(out); + } +}; + +template <size_t N> +auto vformat_to(char (&out)[N], string_view fmt, format_args args) + -> format_to_result<char*> { + auto result = vformat_to_n(out, N, fmt, args); + return {result.out, result.size > N}; +} + +template <size_t N, typename... T> +FMT_INLINE auto format_to(char (&out)[N], format_string<T...> fmt, T&&... args) + -> format_to_result<char*> { + auto result = fmt::format_to_n(out, N, fmt, static_cast<T&&>(args)...); + return {result.out, result.size > N}; +} + +/// Returns the number of chars in the output of `format(fmt, args...)`. +template <typename... T> +FMT_NODISCARD FMT_INLINE auto formatted_size(format_string<T...> fmt, + T&&... args) -> size_t { + auto buf = detail::counting_buffer<>(); + detail::vformat_to<char>(buf, fmt, fmt::make_format_args(args...), {}); + return buf.count(); +} + +FMT_API void vprint(string_view fmt, format_args args); +FMT_API void vprint(FILE* f, string_view fmt, format_args args); +FMT_API void vprint_buffered(FILE* f, string_view fmt, format_args args); +FMT_API void vprintln(FILE* f, string_view fmt, format_args args); + +/** + * Formats `args` according to specifications in `fmt` and writes the output + * to `stdout`. + * + * **Example**: + * + * fmt::print("The answer is {}.", 42); + */ +template <typename... T> +FMT_INLINE void print(format_string<T...> fmt, T&&... args) { + const auto& vargs = fmt::make_format_args(args...); + if (!detail::use_utf8()) return detail::vprint_mojibake(stdout, fmt, vargs); + return detail::is_locking<T...>() ? vprint_buffered(stdout, fmt, vargs) + : vprint(fmt, vargs); +} + +/** + * Formats `args` according to specifications in `fmt` and writes the + * output to the file `f`. + * + * **Example**: + * + * fmt::print(stderr, "Don't {}!", "panic"); + */ +template <typename... T> +FMT_INLINE void print(FILE* f, format_string<T...> fmt, T&&... args) { + const auto& vargs = fmt::make_format_args(args...); + if (!detail::use_utf8()) return detail::vprint_mojibake(f, fmt, vargs); + return detail::is_locking<T...>() ? vprint_buffered(f, fmt, vargs) + : vprint(f, fmt, vargs); +} + +/// Formats `args` according to specifications in `fmt` and writes the output +/// to the file `f` followed by a newline. +template <typename... T> +FMT_INLINE void println(FILE* f, format_string<T...> fmt, T&&... args) { + const auto& vargs = fmt::make_format_args(args...); + return detail::use_utf8() ? vprintln(f, fmt, vargs) + : detail::vprint_mojibake(f, fmt, vargs, true); +} + +/// Formats `args` according to specifications in `fmt` and writes the output +/// to `stdout` followed by a newline. +template <typename... T> +FMT_INLINE void println(format_string<T...> fmt, T&&... args) { + return fmt::println(stdout, fmt, static_cast<T&&>(args)...); +} + +FMT_END_EXPORT +FMT_GCC_PRAGMA("GCC pop_options") +FMT_END_NAMESPACE + +#ifdef FMT_HEADER_ONLY +# include "format.h" +#endif +#endif // FMT_BASE_H_ diff --git a/contrib/fmt/include/fmt/chrono.h b/contrib/fmt/include/fmt/chrono.h index 55e8a5067..c93123fd3 100644 --- a/contrib/fmt/include/fmt/chrono.h +++ b/contrib/fmt/include/fmt/chrono.h @@ -8,15 +8,17 @@ #ifndef FMT_CHRONO_H_ #define FMT_CHRONO_H_ -#include <algorithm> -#include <chrono> -#include <cmath> // std::isfinite -#include <cstring> // std::memcpy -#include <ctime> -#include <iterator> -#include <locale> -#include <ostream> -#include <type_traits> +#ifndef FMT_MODULE +# include <algorithm> +# include <chrono> +# include <cmath> // std::isfinite +# include <cstring> // std::memcpy +# include <ctime> +# include <iterator> +# include <locale> +# include <ostream> +# include <type_traits> +#endif #include "format.h" @@ -72,7 +74,8 @@ template <typename To, typename From, FMT_ENABLE_IF(!std::is_same<From, To>::value && std::numeric_limits<From>::is_signed == std::numeric_limits<To>::is_signed)> -FMT_CONSTEXPR To lossless_integral_conversion(const From from, int& ec) { +FMT_CONSTEXPR auto lossless_integral_conversion(const From from, int& ec) + -> To { ec = 0; using F = std::numeric_limits<From>; using T = std::numeric_limits<To>; @@ -93,15 +96,14 @@ FMT_CONSTEXPR To lossless_integral_conversion(const From from, int& ec) { return static_cast<To>(from); } -/** - * converts From to To, without loss. If the dynamic value of from - * can't be converted to To without loss, ec is set. - */ +/// Converts From to To, without loss. If the dynamic value of from +/// can't be converted to To without loss, ec is set. template <typename To, typename From, FMT_ENABLE_IF(!std::is_same<From, To>::value && std::numeric_limits<From>::is_signed != std::numeric_limits<To>::is_signed)> -FMT_CONSTEXPR To lossless_integral_conversion(const From from, int& ec) { +FMT_CONSTEXPR auto lossless_integral_conversion(const From from, int& ec) + -> To { ec = 0; using F = std::numeric_limits<From>; using T = std::numeric_limits<To>; @@ -133,7 +135,8 @@ FMT_CONSTEXPR To lossless_integral_conversion(const From from, int& ec) { template <typename To, typename From, FMT_ENABLE_IF(std::is_same<From, To>::value)> -FMT_CONSTEXPR To lossless_integral_conversion(const From from, int& ec) { +FMT_CONSTEXPR auto lossless_integral_conversion(const From from, int& ec) + -> To { ec = 0; return from; } // function @@ -154,7 +157,7 @@ FMT_CONSTEXPR To lossless_integral_conversion(const From from, int& ec) { // clang-format on template <typename To, typename From, FMT_ENABLE_IF(!std::is_same<From, To>::value)> -FMT_CONSTEXPR To safe_float_conversion(const From from, int& ec) { +FMT_CONSTEXPR auto safe_float_conversion(const From from, int& ec) -> To { ec = 0; using T = std::numeric_limits<To>; static_assert(std::is_floating_point<From>::value, "From must be floating"); @@ -176,20 +179,18 @@ FMT_CONSTEXPR To safe_float_conversion(const From from, int& ec) { template <typename To, typename From, FMT_ENABLE_IF(std::is_same<From, To>::value)> -FMT_CONSTEXPR To safe_float_conversion(const From from, int& ec) { +FMT_CONSTEXPR auto safe_float_conversion(const From from, int& ec) -> To { ec = 0; static_assert(std::is_floating_point<From>::value, "From must be floating"); return from; } -/** - * safe duration cast between integral durations - */ +/// Safe duration cast between integral durations template <typename To, typename FromRep, typename FromPeriod, FMT_ENABLE_IF(std::is_integral<FromRep>::value), FMT_ENABLE_IF(std::is_integral<typename To::rep>::value)> -To safe_duration_cast(std::chrono::duration<FromRep, FromPeriod> from, - int& ec) { +auto safe_duration_cast(std::chrono::duration<FromRep, FromPeriod> from, + int& ec) -> To { using From = std::chrono::duration<FromRep, FromPeriod>; ec = 0; // the basic idea is that we need to convert from count() in the from type @@ -234,14 +235,12 @@ To safe_duration_cast(std::chrono::duration<FromRep, FromPeriod> from, return ec ? To() : To(tocount); } -/** - * safe duration_cast between floating point durations - */ +/// Safe duration_cast between floating point durations template <typename To, typename FromRep, typename FromPeriod, FMT_ENABLE_IF(std::is_floating_point<FromRep>::value), FMT_ENABLE_IF(std::is_floating_point<typename To::rep>::value)> -To safe_duration_cast(std::chrono::duration<FromRep, FromPeriod> from, - int& ec) { +auto safe_duration_cast(std::chrono::duration<FromRep, FromPeriod> from, + int& ec) -> To { using From = std::chrono::duration<FromRep, FromPeriod>; ec = 0; if (std::isnan(from.count())) { @@ -321,12 +320,45 @@ To safe_duration_cast(std::chrono::duration<FromRep, FromPeriod> from, namespace detail { template <typename T = void> struct null {}; -inline null<> localtime_r FMT_NOMACRO(...) { return null<>(); } -inline null<> localtime_s(...) { return null<>(); } -inline null<> gmtime_r(...) { return null<>(); } -inline null<> gmtime_s(...) { return null<>(); } +inline auto localtime_r FMT_NOMACRO(...) -> null<> { return null<>(); } +inline auto localtime_s(...) -> null<> { return null<>(); } +inline auto gmtime_r(...) -> null<> { return null<>(); } +inline auto gmtime_s(...) -> null<> { return null<>(); } + +// It is defined here and not in ostream.h because the latter has expensive +// includes. +template <typename Streambuf> class formatbuf : public Streambuf { + private: + using char_type = typename Streambuf::char_type; + using streamsize = decltype(std::declval<Streambuf>().sputn(nullptr, 0)); + using int_type = typename Streambuf::int_type; + using traits_type = typename Streambuf::traits_type; + + buffer<char_type>& buffer_; + + public: + explicit formatbuf(buffer<char_type>& buf) : buffer_(buf) {} + + protected: + // The put area is always empty. This makes the implementation simpler and has + // the advantage that the streambuf and the buffer are always in sync and + // sputc never writes into uninitialized memory. A disadvantage is that each + // call to sputc always results in a (virtual) call to overflow. There is no + // disadvantage here for sputn since this always results in a call to xsputn. -inline const std::locale& get_classic_locale() { + auto overflow(int_type ch) -> int_type override { + if (!traits_type::eq_int_type(ch, traits_type::eof())) + buffer_.push_back(static_cast<char_type>(ch)); + return ch; + } + + auto xsputn(const char_type* s, streamsize count) -> streamsize override { + buffer_.append(s, s + count); + return count; + } +}; + +inline auto get_classic_locale() -> const std::locale& { static const auto& locale = std::locale::classic(); return locale; } @@ -336,8 +368,6 @@ template <typename CodeUnit> struct codecvt_result { CodeUnit buf[max_size]; CodeUnit* end; }; -template <typename CodeUnit> -constexpr const size_t codecvt_result<CodeUnit>::max_size; template <typename CodeUnit> void write_codecvt(codecvt_result<CodeUnit>& out, string_view in_buf, @@ -361,11 +391,12 @@ void write_codecvt(codecvt_result<CodeUnit>& out, string_view in_buf, template <typename OutputIt> auto write_encoded_tm_str(OutputIt out, string_view in, const std::locale& loc) -> OutputIt { - if (detail::is_utf8() && loc != get_classic_locale()) { + if (detail::use_utf8() && loc != get_classic_locale()) { // char16_t and char32_t codecvts are broken in MSVC (linkage errors) and // gcc-4. -#if FMT_MSC_VERSION != 0 || \ - (defined(__GLIBCXX__) && !defined(_GLIBCXX_USE_DUAL_ABI)) +#if FMT_MSC_VERSION != 0 || \ + (defined(__GLIBCXX__) && \ + (!defined(_GLIBCXX_USE_DUAL_ABI) || _GLIBCXX_USE_DUAL_ABI == 0)) // The _GLIBCXX_USE_DUAL_ABI macro is always defined in libstdc++ from gcc-5 // and newer. using code_unit = wchar_t; @@ -377,13 +408,13 @@ auto write_encoded_tm_str(OutputIt out, string_view in, const std::locale& loc) unit_t unit; write_codecvt(unit, in, loc); // In UTF-8 is used one to four one-byte code units. - unicode_to_utf8<code_unit, basic_memory_buffer<char, unit_t::max_size * 4>> - u; + auto u = + to_utf8<code_unit, basic_memory_buffer<char, unit_t::max_size * 4>>(); if (!u.convert({unit.buf, to_unsigned(unit.end - unit.buf)})) FMT_THROW(format_error("failed to format time")); - return copy_str<char>(u.c_str(), u.c_str() + u.size(), out); + return copy<char>(u.c_str(), u.c_str() + u.size(), out); } - return copy_str<char>(in.data(), in.data() + in.size(), out); + return copy<char>(in.data(), in.data() + in.size(), out); } template <typename Char, typename OutputIt, @@ -392,7 +423,7 @@ auto write_tm_str(OutputIt out, string_view sv, const std::locale& loc) -> OutputIt { codecvt_result<Char> unit; write_codecvt(unit, sv, loc); - return copy_str<Char>(unit.buf, unit.end, out); + return copy<Char>(unit.buf, unit.end, out); } template <typename Char, typename OutputIt, @@ -408,8 +439,7 @@ inline void do_write(buffer<Char>& buf, const std::tm& time, auto&& format_buf = formatbuf<std::basic_streambuf<Char>>(buf); auto&& os = std::basic_ostream<Char>(&format_buf); os.imbue(loc); - using iterator = std::ostreambuf_iterator<Char>; - const auto& facet = std::use_facet<std::time_put<Char, iterator>>(loc); + const auto& facet = std::use_facet<std::time_put<Char>>(loc); auto end = facet.put(os, os, Char(' '), &time, format, modifier); if (end.failed()) FMT_THROW(format_error("failed to format time")); } @@ -432,38 +462,83 @@ auto write(OutputIt out, const std::tm& time, const std::locale& loc, return write_encoded_tm_str(out, string_view(buf.data(), buf.size()), loc); } +template <typename Rep1, typename Rep2> +struct is_same_arithmetic_type + : public std::integral_constant<bool, + (std::is_integral<Rep1>::value && + std::is_integral<Rep2>::value) || + (std::is_floating_point<Rep1>::value && + std::is_floating_point<Rep2>::value)> { +}; + +template < + typename To, typename FromRep, typename FromPeriod, + FMT_ENABLE_IF(is_same_arithmetic_type<FromRep, typename To::rep>::value)> +auto fmt_duration_cast(std::chrono::duration<FromRep, FromPeriod> from) -> To { +#if FMT_SAFE_DURATION_CAST + // Throwing version of safe_duration_cast is only available for + // integer to integer or float to float casts. + int ec; + To to = safe_duration_cast::safe_duration_cast<To>(from, ec); + if (ec) FMT_THROW(format_error("cannot format duration")); + return to; +#else + // Standard duration cast, may overflow. + return std::chrono::duration_cast<To>(from); +#endif +} + +template < + typename To, typename FromRep, typename FromPeriod, + FMT_ENABLE_IF(!is_same_arithmetic_type<FromRep, typename To::rep>::value)> +auto fmt_duration_cast(std::chrono::duration<FromRep, FromPeriod> from) -> To { + // Mixed integer <-> float cast is not supported by safe_duration_cast. + return std::chrono::duration_cast<To>(from); +} + +template <typename Duration> +auto to_time_t( + std::chrono::time_point<std::chrono::system_clock, Duration> time_point) + -> std::time_t { + // Cannot use std::chrono::system_clock::to_time_t since this would first + // require a cast to std::chrono::system_clock::time_point, which could + // overflow. + return fmt_duration_cast<std::chrono::duration<std::time_t>>( + time_point.time_since_epoch()) + .count(); +} } // namespace detail FMT_BEGIN_EXPORT /** - Converts given time since epoch as ``std::time_t`` value into calendar time, - expressed in local time. Unlike ``std::localtime``, this function is - thread-safe on most platforms. + * Converts given time since epoch as `std::time_t` value into calendar time, + * expressed in local time. Unlike `std::localtime`, this function is + * thread-safe on most platforms. */ -inline std::tm localtime(std::time_t time) { +inline auto localtime(std::time_t time) -> std::tm { struct dispatcher { std::time_t time_; std::tm tm_; dispatcher(std::time_t t) : time_(t) {} - bool run() { + auto run() -> bool { using namespace fmt::detail; return handle(localtime_r(&time_, &tm_)); } - bool handle(std::tm* tm) { return tm != nullptr; } + auto handle(std::tm* tm) -> bool { return tm != nullptr; } - bool handle(detail::null<>) { + auto handle(detail::null<>) -> bool { using namespace fmt::detail; return fallback(localtime_s(&tm_, &time_)); } - bool fallback(int res) { return res == 0; } + auto fallback(int res) -> bool { return res == 0; } #if !FMT_MSC_VERSION - bool fallback(detail::null<>) { + auto fallback(detail::null<>) -> bool { using namespace fmt::detail; std::tm* tm = std::localtime(&time_); if (tm) tm_ = *tm; @@ -480,100 +555,59 @@ inline std::tm localtime(std::time_t time) { #if FMT_USE_LOCAL_TIME template <typename Duration> inline auto localtime(std::chrono::local_time<Duration> time) -> std::tm { - return localtime(std::chrono::system_clock::to_time_t( - std::chrono::current_zone()->to_sys(time))); + return localtime( + detail::to_time_t(std::chrono::current_zone()->to_sys(time))); } #endif /** - Converts given time since epoch as ``std::time_t`` value into calendar time, - expressed in Coordinated Universal Time (UTC). Unlike ``std::gmtime``, this - function is thread-safe on most platforms. + * Converts given time since epoch as `std::time_t` value into calendar time, + * expressed in Coordinated Universal Time (UTC). Unlike `std::gmtime`, this + * function is thread-safe on most platforms. */ -inline std::tm gmtime(std::time_t time) { +inline auto gmtime(std::time_t time) -> std::tm { struct dispatcher { std::time_t time_; std::tm tm_; dispatcher(std::time_t t) : time_(t) {} - bool run() { + auto run() -> bool { using namespace fmt::detail; return handle(gmtime_r(&time_, &tm_)); } - bool handle(std::tm* tm) { return tm != nullptr; } + auto handle(std::tm* tm) -> bool { return tm != nullptr; } - bool handle(detail::null<>) { + auto handle(detail::null<>) -> bool { using namespace fmt::detail; return fallback(gmtime_s(&tm_, &time_)); } - bool fallback(int res) { return res == 0; } + auto fallback(int res) -> bool { return res == 0; } #if !FMT_MSC_VERSION - bool fallback(detail::null<>) { + auto fallback(detail::null<>) -> bool { std::tm* tm = std::gmtime(&time_); if (tm) tm_ = *tm; return tm != nullptr; } #endif }; - dispatcher gt(time); + auto gt = dispatcher(time); // Too big time values may be unsupported. if (!gt.run()) FMT_THROW(format_error("time_t value out of range")); return gt.tm_; } -inline std::tm gmtime( - std::chrono::time_point<std::chrono::system_clock> time_point) { - return gmtime(std::chrono::system_clock::to_time_t(time_point)); +template <typename Duration> +inline auto gmtime( + std::chrono::time_point<std::chrono::system_clock, Duration> time_point) + -> std::tm { + return gmtime(detail::to_time_t(time_point)); } -FMT_BEGIN_DETAIL_NAMESPACE - -// DEPRECATED! -template <typename Char> -FMT_CONSTEXPR auto parse_align(const Char* begin, const Char* end, - format_specs<Char>& specs) -> const Char* { - FMT_ASSERT(begin != end, ""); - auto align = align::none; - auto p = begin + code_point_length(begin); - if (end - p <= 0) p = begin; - for (;;) { - switch (to_ascii(*p)) { - case '<': - align = align::left; - break; - case '>': - align = align::right; - break; - case '^': - align = align::center; - break; - } - if (align != align::none) { - if (p != begin) { - auto c = *begin; - if (c == '}') return begin; - if (c == '{') { - throw_format_error("invalid fill character '{'"); - return begin; - } - specs.fill = {begin, to_unsigned(p - begin)}; - begin = p + 1; - } else { - ++begin; - } - break; - } else if (p == begin) { - break; - } - p = begin; - } - specs.align = align; - return begin; -} +namespace detail { // Writes two-digit numbers a, b and c separated by sep to buf. // The method by Pavel Novikov based on @@ -609,7 +643,8 @@ inline void write_digit2_separated(char* buf, unsigned a, unsigned b, } } -template <typename Period> FMT_CONSTEXPR inline const char* get_units() { +template <typename Period> +FMT_CONSTEXPR inline auto get_units() -> const char* { if (std::is_same<Period, std::atto>::value) return "as"; if (std::is_same<Period, std::femto>::value) return "fs"; if (std::is_same<Period, std::pico>::value) return "ps"; @@ -627,8 +662,9 @@ template <typename Period> FMT_CONSTEXPR inline const char* get_units() { if (std::is_same<Period, std::tera>::value) return "Ts"; if (std::is_same<Period, std::peta>::value) return "Ps"; if (std::is_same<Period, std::exa>::value) return "Es"; - if (std::is_same<Period, std::ratio<60>>::value) return "m"; + if (std::is_same<Period, std::ratio<60>>::value) return "min"; if (std::is_same<Period, std::ratio<3600>>::value) return "h"; + if (std::is_same<Period, std::ratio<86400>>::value) return "d"; return nullptr; } @@ -640,12 +676,10 @@ enum class numeric_system { // Glibc extensions for formatting numeric values. enum class pad_type { - unspecified, + // Pad a numeric result string with zeros (the default). + zero, // Do not pad a numeric result string. none, - // Pad a numeric result string with zeros even if the conversion specifier - // character uses space-padding by default. - zero, // Pad a numeric result string with spaces. space, }; @@ -653,7 +687,7 @@ enum class pad_type { template <typename OutputIt> auto write_padding(OutputIt out, pad_type pad, int width) -> OutputIt { if (pad == pad_type::none) return out; - return std::fill_n(out, width, pad == pad_type::space ? ' ' : '0'); + return detail::fill_n(out, width, pad == pad_type::space ? ' ' : '0'); } template <typename OutputIt> @@ -664,14 +698,13 @@ auto write_padding(OutputIt out, pad_type pad) -> OutputIt { // Parses a put_time-like format string and invokes handler actions. template <typename Char, typename Handler> -FMT_CONSTEXPR const Char* parse_chrono_format(const Char* begin, - const Char* end, - Handler&& handler) { +FMT_CONSTEXPR auto parse_chrono_format(const Char* begin, const Char* end, + Handler&& handler) -> const Char* { if (begin == end || *begin == '}') return begin; if (*begin != '%') FMT_THROW(format_error("invalid format")); auto ptr = begin; - pad_type pad = pad_type::unspecified; while (ptr != end) { + pad_type pad = pad_type::zero; auto c = *ptr; if (c == '}') break; if (c != '%') { @@ -691,10 +724,6 @@ FMT_CONSTEXPR const Char* parse_chrono_format(const Char* begin, pad = pad_type::none; ++ptr; break; - case '0': - pad = pad_type::zero; - ++ptr; - break; } if (ptr == end) FMT_THROW(format_error("invalid format")); c = *ptr++; @@ -754,22 +783,22 @@ FMT_CONSTEXPR const Char* parse_chrono_format(const Char* begin, break; // Day of the year/month: case 'U': - handler.on_dec0_week_of_year(numeric_system::standard); + handler.on_dec0_week_of_year(numeric_system::standard, pad); break; case 'W': - handler.on_dec1_week_of_year(numeric_system::standard); + handler.on_dec1_week_of_year(numeric_system::standard, pad); break; case 'V': - handler.on_iso_week_of_year(numeric_system::standard); + handler.on_iso_week_of_year(numeric_system::standard, pad); break; case 'j': handler.on_day_of_year(); break; case 'd': - handler.on_day_of_month(numeric_system::standard); + handler.on_day_of_month(numeric_system::standard, pad); break; case 'e': - handler.on_day_of_month_space(numeric_system::standard); + handler.on_day_of_month(numeric_system::standard, pad_type::space); break; // Hour, minute, second: case 'H': @@ -866,19 +895,19 @@ FMT_CONSTEXPR const Char* parse_chrono_format(const Char* begin, handler.on_dec_month(numeric_system::alternative); break; case 'U': - handler.on_dec0_week_of_year(numeric_system::alternative); + handler.on_dec0_week_of_year(numeric_system::alternative, pad); break; case 'W': - handler.on_dec1_week_of_year(numeric_system::alternative); + handler.on_dec1_week_of_year(numeric_system::alternative, pad); break; case 'V': - handler.on_iso_week_of_year(numeric_system::alternative); + handler.on_iso_week_of_year(numeric_system::alternative, pad); break; case 'd': - handler.on_day_of_month(numeric_system::alternative); + handler.on_day_of_month(numeric_system::alternative, pad); break; case 'e': - handler.on_day_of_month_space(numeric_system::alternative); + handler.on_day_of_month(numeric_system::alternative, pad_type::space); break; case 'w': handler.on_dec0_weekday(numeric_system::alternative); @@ -931,12 +960,19 @@ template <typename Derived> struct null_chrono_spec_handler { FMT_CONSTEXPR void on_abbr_month() { unsupported(); } FMT_CONSTEXPR void on_full_month() { unsupported(); } FMT_CONSTEXPR void on_dec_month(numeric_system) { unsupported(); } - FMT_CONSTEXPR void on_dec0_week_of_year(numeric_system) { unsupported(); } - FMT_CONSTEXPR void on_dec1_week_of_year(numeric_system) { unsupported(); } - FMT_CONSTEXPR void on_iso_week_of_year(numeric_system) { unsupported(); } + FMT_CONSTEXPR void on_dec0_week_of_year(numeric_system, pad_type) { + unsupported(); + } + FMT_CONSTEXPR void on_dec1_week_of_year(numeric_system, pad_type) { + unsupported(); + } + FMT_CONSTEXPR void on_iso_week_of_year(numeric_system, pad_type) { + unsupported(); + } FMT_CONSTEXPR void on_day_of_year() { unsupported(); } - FMT_CONSTEXPR void on_day_of_month(numeric_system) { unsupported(); } - FMT_CONSTEXPR void on_day_of_month_space(numeric_system) { unsupported(); } + FMT_CONSTEXPR void on_day_of_month(numeric_system, pad_type) { + unsupported(); + } FMT_CONSTEXPR void on_24_hour(numeric_system) { unsupported(); } FMT_CONSTEXPR void on_12_hour(numeric_system) { unsupported(); } FMT_CONSTEXPR void on_minute(numeric_system) { unsupported(); } @@ -974,12 +1010,11 @@ struct tm_format_checker : null_chrono_spec_handler<tm_format_checker> { FMT_CONSTEXPR void on_abbr_month() {} FMT_CONSTEXPR void on_full_month() {} FMT_CONSTEXPR void on_dec_month(numeric_system) {} - FMT_CONSTEXPR void on_dec0_week_of_year(numeric_system) {} - FMT_CONSTEXPR void on_dec1_week_of_year(numeric_system) {} - FMT_CONSTEXPR void on_iso_week_of_year(numeric_system) {} + FMT_CONSTEXPR void on_dec0_week_of_year(numeric_system, pad_type) {} + FMT_CONSTEXPR void on_dec1_week_of_year(numeric_system, pad_type) {} + FMT_CONSTEXPR void on_iso_week_of_year(numeric_system, pad_type) {} FMT_CONSTEXPR void on_day_of_year() {} - FMT_CONSTEXPR void on_day_of_month(numeric_system) {} - FMT_CONSTEXPR void on_day_of_month_space(numeric_system) {} + FMT_CONSTEXPR void on_day_of_month(numeric_system, pad_type) {} FMT_CONSTEXPR void on_24_hour(numeric_system, pad_type) {} FMT_CONSTEXPR void on_12_hour(numeric_system, pad_type) {} FMT_CONSTEXPR void on_minute(numeric_system, pad_type) {} @@ -997,25 +1032,25 @@ struct tm_format_checker : null_chrono_spec_handler<tm_format_checker> { FMT_CONSTEXPR void on_tz_name() {} }; -inline const char* tm_wday_full_name(int wday) { +inline auto tm_wday_full_name(int wday) -> const char* { static constexpr const char* full_name_list[] = { "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"}; return wday >= 0 && wday <= 6 ? full_name_list[wday] : "?"; } -inline const char* tm_wday_short_name(int wday) { +inline auto tm_wday_short_name(int wday) -> const char* { static constexpr const char* short_name_list[] = {"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"}; return wday >= 0 && wday <= 6 ? short_name_list[wday] : "???"; } -inline const char* tm_mon_full_name(int mon) { +inline auto tm_mon_full_name(int mon) -> const char* { static constexpr const char* full_name_list[] = { "January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"}; return mon >= 0 && mon <= 11 ? full_name_list[mon] : "?"; } -inline const char* tm_mon_short_name(int mon) { +inline auto tm_mon_short_name(int mon) -> const char* { static constexpr const char* short_name_list[] = { "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec", @@ -1047,21 +1082,22 @@ inline void tzset_once() { // Converts value to Int and checks that it's in the range [0, upper). template <typename T, typename Int, FMT_ENABLE_IF(std::is_integral<T>::value)> -inline Int to_nonnegative_int(T value, Int upper) { - FMT_ASSERT(std::is_unsigned<Int>::value || - (value >= 0 && to_unsigned(value) <= to_unsigned(upper)), - "invalid value"); - (void)upper; +inline auto to_nonnegative_int(T value, Int upper) -> Int { + if (!std::is_unsigned<Int>::value && + (value < 0 || to_unsigned(value) > to_unsigned(upper))) { + FMT_THROW(fmt::format_error("chrono value is out of range")); + } return static_cast<Int>(value); } template <typename T, typename Int, FMT_ENABLE_IF(!std::is_integral<T>::value)> -inline Int to_nonnegative_int(T value, Int upper) { - if (value < 0 || value > static_cast<T>(upper)) +inline auto to_nonnegative_int(T value, Int upper) -> Int { + auto int_value = static_cast<Int>(value); + if (int_value < 0 || value > static_cast<T>(upper)) FMT_THROW(format_error("invalid value")); - return static_cast<Int>(value); + return int_value; } -constexpr long long pow10(std::uint32_t n) { +constexpr auto pow10(std::uint32_t n) -> long long { return n == 0 ? 1 : 10 * pow10(n - 1); } @@ -1095,13 +1131,12 @@ void write_fractional_seconds(OutputIt& out, Duration d, int precision = -1) { std::chrono::seconds::rep>::type, std::ratio<1, detail::pow10(num_fractional_digits)>>; - const auto fractional = - d - std::chrono::duration_cast<std::chrono::seconds>(d); + const auto fractional = d - fmt_duration_cast<std::chrono::seconds>(d); const auto subseconds = std::chrono::treat_as_floating_point< typename subsecond_precision::rep>::value ? fractional.count() - : std::chrono::duration_cast<subsecond_precision>(fractional).count(); + : fmt_duration_cast<subsecond_precision>(fractional).count(); auto n = static_cast<uint32_or_64_or_128_t<long long>>(subseconds); const int num_digits = detail::count_digits(n); @@ -1111,22 +1146,27 @@ void write_fractional_seconds(OutputIt& out, Duration d, int precision = -1) { if (std::ratio_less<typename subsecond_precision::period, std::chrono::seconds::period>::value) { *out++ = '.'; - out = std::fill_n(out, leading_zeroes, '0'); + out = detail::fill_n(out, leading_zeroes, '0'); out = format_decimal<Char>(out, n, num_digits).end; } - } else { + } else if (precision > 0) { *out++ = '.'; leading_zeroes = (std::min)(leading_zeroes, precision); - out = std::fill_n(out, leading_zeroes, '0'); int remaining = precision - leading_zeroes; - if (remaining != 0 && remaining < num_digits) { - n /= to_unsigned(detail::pow10(to_unsigned(num_digits - remaining))); - out = format_decimal<Char>(out, n, remaining).end; + out = detail::fill_n(out, leading_zeroes, '0'); + if (remaining < num_digits) { + int num_truncated_digits = num_digits - remaining; + n /= to_unsigned(detail::pow10(to_unsigned(num_truncated_digits))); + if (n) { + out = format_decimal<Char>(out, n, remaining).end; + } return; } - out = format_decimal<Char>(out, n, num_digits).end; - remaining -= num_digits; - out = std::fill_n(out, remaining, '0'); + if (n) { + out = format_decimal<Char>(out, n, num_digits).end; + remaining -= num_digits; + } + out = detail::fill_n(out, remaining, '0'); } } @@ -1152,11 +1192,11 @@ void write_floating_seconds(memory_buffer& buf, Duration duration, num_fractional_digits = 6; } - format_to(std::back_inserter(buf), FMT_STRING("{:.{}f}"), - std::fmod(val * static_cast<rep>(Duration::period::num) / - static_cast<rep>(Duration::period::den), - static_cast<rep>(60)), - num_fractional_digits); + fmt::format_to(std::back_inserter(buf), FMT_STRING("{:.{}f}"), + std::fmod(val * static_cast<rep>(Duration::period::num) / + static_cast<rep>(Duration::period::den), + static_cast<rep>(60)), + num_fractional_digits); } template <typename OutputIt, typename Char, @@ -1217,8 +1257,7 @@ class tm_writer { return static_cast<int>(l); } - // Algorithm: - // https://en.wikipedia.org/wiki/ISO_week_date#Calculating_the_week_number_from_a_month_and_day_of_the_month_or_ordinal_date + // Algorithm: https://en.wikipedia.org/wiki/ISO_week_date. auto iso_year_weeks(long long curr_year) const noexcept -> int { const auto prev_year = curr_year - 1; const auto curr_p = @@ -1278,7 +1317,8 @@ class tm_writer { } uint32_or_64_or_128_t<long long> n = to_unsigned(year); const int num_digits = count_digits(n); - if (width > num_digits) out_ = std::fill_n(out_, width - num_digits, '0'); + if (width > num_digits) + out_ = detail::fill_n(out_, width - num_digits, '0'); out_ = format_decimal<Char>(out_, n, num_digits).end; } void write_year(long long year) { @@ -1358,10 +1398,10 @@ class tm_writer { subsecs_(subsecs), tm_(tm) {} - OutputIt out() const { return out_; } + auto out() const -> OutputIt { return out_; } FMT_CONSTEXPR void on_text(const Char* begin, const Char* end) { - out_ = copy_str<Char>(begin, end, out_); + out_ = copy<Char>(begin, end, out_); } void on_abbr_weekday() { @@ -1408,7 +1448,7 @@ class tm_writer { *out_++ = ' '; on_abbr_month(); *out_++ = ' '; - on_day_of_month_space(numeric_system::standard); + on_day_of_month(numeric_system::standard, pad_type::space); *out_++ = ' '; on_iso_time(); *out_++ = ' '; @@ -1434,7 +1474,7 @@ class tm_writer { write_digit2_separated(buf, to_unsigned(tm_mon() + 1), to_unsigned(tm_mday()), to_unsigned(split_year_lower(tm_year())), '/'); - out_ = copy_str<Char>(std::begin(buf), std::end(buf), out_); + out_ = copy<Char>(std::begin(buf), std::end(buf), out_); } void on_iso_date() { auto year = tm_year(); @@ -1450,7 +1490,7 @@ class tm_writer { write_digit2_separated(buf + 2, static_cast<unsigned>(year % 100), to_unsigned(tm_mon() + 1), to_unsigned(tm_mday()), '-'); - out_ = copy_str<Char>(std::begin(buf) + offset, std::end(buf), out_); + out_ = copy<Char>(std::begin(buf) + offset, std::end(buf), out_); } void on_utc_offset(numeric_system ns) { format_utc_offset_impl(tm_, ns); } @@ -1495,24 +1535,26 @@ class tm_writer { format_localized('m', 'O'); } - void on_dec0_week_of_year(numeric_system ns) { + void on_dec0_week_of_year(numeric_system ns, pad_type pad) { if (is_classic_ || ns == numeric_system::standard) - return write2((tm_yday() + days_per_week - tm_wday()) / days_per_week); + return write2((tm_yday() + days_per_week - tm_wday()) / days_per_week, + pad); format_localized('U', 'O'); } - void on_dec1_week_of_year(numeric_system ns) { + void on_dec1_week_of_year(numeric_system ns, pad_type pad) { if (is_classic_ || ns == numeric_system::standard) { auto wday = tm_wday(); write2((tm_yday() + days_per_week - (wday == 0 ? (days_per_week - 1) : (wday - 1))) / - days_per_week); + days_per_week, + pad); } else { format_localized('W', 'O'); } } - void on_iso_week_of_year(numeric_system ns) { + void on_iso_week_of_year(numeric_system ns, pad_type pad) { if (is_classic_ || ns == numeric_system::standard) - return write2(tm_iso_week_of_year()); + return write2(tm_iso_week_of_year(), pad); format_localized('V', 'O'); } @@ -1526,20 +1568,11 @@ class tm_writer { write1(yday / 100); write2(yday % 100); } - void on_day_of_month(numeric_system ns) { - if (is_classic_ || ns == numeric_system::standard) return write2(tm_mday()); + void on_day_of_month(numeric_system ns, pad_type pad) { + if (is_classic_ || ns == numeric_system::standard) + return write2(tm_mday(), pad); format_localized('d', 'O'); } - void on_day_of_month_space(numeric_system ns) { - if (is_classic_ || ns == numeric_system::standard) { - auto mday = to_unsigned(tm_mday()) % 100; - const char* d2 = digits2(mday); - *out_++ = mday < 10 ? ' ' : d2[0]; - *out_++ = d2[1]; - } else { - format_localized('e', 'O'); - } - } void on_24_hour(numeric_system ns, pad_type pad) { if (is_classic_ || ns == numeric_system::standard) @@ -1583,7 +1616,7 @@ class tm_writer { char buf[8]; write_digit2_separated(buf, to_unsigned(tm_hour12()), to_unsigned(tm_min()), to_unsigned(tm_sec()), ':'); - out_ = copy_str<Char>(std::begin(buf), std::end(buf), out_); + out_ = copy<Char>(std::begin(buf), std::end(buf), out_); *out_++ = ' '; on_am_pm(); } else { @@ -1598,7 +1631,7 @@ class tm_writer { void on_iso_time() { on_24_hour_time(); *out_++ = ':'; - on_second(numeric_system::standard, pad_type::unspecified); + on_second(numeric_system::standard, pad_type::zero); } void on_am_pm() { @@ -1622,6 +1655,7 @@ struct chrono_format_checker : null_chrono_spec_handler<chrono_format_checker> { template <typename Char> FMT_CONSTEXPR void on_text(const Char*, const Char*) {} + FMT_CONSTEXPR void on_day_of_year() {} FMT_CONSTEXPR void on_24_hour(numeric_system, pad_type) {} FMT_CONSTEXPR void on_12_hour(numeric_system, pad_type) {} FMT_CONSTEXPR void on_minute(numeric_system, pad_type) {} @@ -1640,16 +1674,16 @@ struct chrono_format_checker : null_chrono_spec_handler<chrono_format_checker> { template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value&& has_isfinite<T>::value)> -inline bool isfinite(T) { +inline auto isfinite(T) -> bool { return true; } template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)> -inline T mod(T x, int y) { +inline auto mod(T x, int y) -> T { return x % static_cast<T>(y); } template <typename T, FMT_ENABLE_IF(std::is_floating_point<T>::value)> -inline T mod(T x, int y) { +inline auto mod(T x, int y) -> T { return std::fmod(x, static_cast<T>(y)); } @@ -1664,63 +1698,52 @@ template <typename T> struct make_unsigned_or_unchanged<T, true> { using type = typename std::make_unsigned<T>::type; }; -#if FMT_SAFE_DURATION_CAST -// throwing version of safe_duration_cast -template <typename To, typename FromRep, typename FromPeriod> -To fmt_safe_duration_cast(std::chrono::duration<FromRep, FromPeriod> from) { - int ec; - To to = safe_duration_cast::safe_duration_cast<To>(from, ec); - if (ec) FMT_THROW(format_error("cannot format duration")); - return to; -} -#endif - template <typename Rep, typename Period, FMT_ENABLE_IF(std::is_integral<Rep>::value)> -inline std::chrono::duration<Rep, std::milli> get_milliseconds( - std::chrono::duration<Rep, Period> d) { +inline auto get_milliseconds(std::chrono::duration<Rep, Period> d) + -> std::chrono::duration<Rep, std::milli> { // this may overflow and/or the result may not fit in the // target type. #if FMT_SAFE_DURATION_CAST using CommonSecondsType = typename std::common_type<decltype(d), std::chrono::seconds>::type; - const auto d_as_common = fmt_safe_duration_cast<CommonSecondsType>(d); + const auto d_as_common = fmt_duration_cast<CommonSecondsType>(d); const auto d_as_whole_seconds = - fmt_safe_duration_cast<std::chrono::seconds>(d_as_common); + fmt_duration_cast<std::chrono::seconds>(d_as_common); // this conversion should be nonproblematic const auto diff = d_as_common - d_as_whole_seconds; const auto ms = - fmt_safe_duration_cast<std::chrono::duration<Rep, std::milli>>(diff); + fmt_duration_cast<std::chrono::duration<Rep, std::milli>>(diff); return ms; #else - auto s = std::chrono::duration_cast<std::chrono::seconds>(d); - return std::chrono::duration_cast<std::chrono::milliseconds>(d - s); + auto s = fmt_duration_cast<std::chrono::seconds>(d); + return fmt_duration_cast<std::chrono::milliseconds>(d - s); #endif } template <typename Char, typename Rep, typename OutputIt, FMT_ENABLE_IF(std::is_integral<Rep>::value)> -OutputIt format_duration_value(OutputIt out, Rep val, int) { +auto format_duration_value(OutputIt out, Rep val, int) -> OutputIt { return write<Char>(out, val); } template <typename Char, typename Rep, typename OutputIt, FMT_ENABLE_IF(std::is_floating_point<Rep>::value)> -OutputIt format_duration_value(OutputIt out, Rep val, int precision) { - auto specs = format_specs<Char>(); +auto format_duration_value(OutputIt out, Rep val, int precision) -> OutputIt { + auto specs = format_specs(); specs.precision = precision; - specs.type = precision >= 0 ? presentation_type::fixed_lower - : presentation_type::general_lower; + specs.type = + precision >= 0 ? presentation_type::fixed : presentation_type::general; return write<Char>(out, val, specs); } template <typename Char, typename OutputIt> -OutputIt copy_unit(string_view unit, OutputIt out, Char) { +auto copy_unit(string_view unit, OutputIt out, Char) -> OutputIt { return std::copy(unit.begin(), unit.end(), out); } template <typename OutputIt> -OutputIt copy_unit(string_view unit, OutputIt out, wchar_t) { +auto copy_unit(string_view unit, OutputIt out, wchar_t) -> OutputIt { // This works when wchar_t is UTF-32 because units only contain characters // that have the same representation in UTF-16 and UTF-32. utf8_to_utf16 u(unit); @@ -1728,7 +1751,7 @@ OutputIt copy_unit(string_view unit, OutputIt out, wchar_t) { } template <typename Char, typename Period, typename OutputIt> -OutputIt format_duration_unit(OutputIt out) { +auto format_duration_unit(OutputIt out) -> OutputIt { if (const char* unit = get_units<Period>()) return copy_unit(string_view(unit), out, Char()); *out++ = '['; @@ -1751,8 +1774,10 @@ class get_locale { public: get_locale(bool localized, locale_ref loc) : has_locale_(localized) { +#ifndef FMT_STATIC_THOUSANDS_SEPARATOR if (localized) ::new (&locale_) std::locale(loc.template get<std::locale>()); +#endif } ~get_locale() { if (has_locale_) locale_.~locale(); @@ -1795,18 +1820,12 @@ struct chrono_formatter { // this may overflow and/or the result may not fit in the // target type. -#if FMT_SAFE_DURATION_CAST // might need checked conversion (rep!=Rep) - auto tmpval = std::chrono::duration<rep, Period>(val); - s = fmt_safe_duration_cast<seconds>(tmpval); -#else - s = std::chrono::duration_cast<seconds>( - std::chrono::duration<rep, Period>(val)); -#endif + s = fmt_duration_cast<seconds>(std::chrono::duration<rep, Period>(val)); } // returns true if nan or inf, writes to out. - bool handle_nan_inf() { + auto handle_nan_inf() -> bool { if (isfinite(val)) { return false; } @@ -1823,17 +1842,22 @@ struct chrono_formatter { return true; } - Rep hour() const { return static_cast<Rep>(mod((s.count() / 3600), 24)); } + auto days() const -> Rep { return static_cast<Rep>(s.count() / 86400); } + auto hour() const -> Rep { + return static_cast<Rep>(mod((s.count() / 3600), 24)); + } - Rep hour12() const { + auto hour12() const -> Rep { Rep hour = static_cast<Rep>(mod((s.count() / 3600), 12)); return hour <= 0 ? 12 : hour; } - Rep minute() const { return static_cast<Rep>(mod((s.count() / 60), 60)); } - Rep second() const { return static_cast<Rep>(mod(s.count(), 60)); } + auto minute() const -> Rep { + return static_cast<Rep>(mod((s.count() / 60), 60)); + } + auto second() const -> Rep { return static_cast<Rep>(mod(s.count(), 60)); } - std::tm time() const { + auto time() const -> std::tm { auto time = std::tm(); time.tm_hour = to_nonnegative_int(hour(), 24); time.tm_min = to_nonnegative_int(minute(), 60); @@ -1848,7 +1872,7 @@ struct chrono_formatter { } } - void write(Rep value, int width, pad_type pad = pad_type::unspecified) { + void write(Rep value, int width, pad_type pad = pad_type::zero) { write_sign(); if (isnan(value)) return write_nan(); uint32_or_64_or_128_t<int> n = @@ -1898,12 +1922,15 @@ struct chrono_formatter { void on_iso_week_based_year() {} void on_iso_week_based_short_year() {} void on_dec_month(numeric_system) {} - void on_dec0_week_of_year(numeric_system) {} - void on_dec1_week_of_year(numeric_system) {} - void on_iso_week_of_year(numeric_system) {} - void on_day_of_year() {} - void on_day_of_month(numeric_system) {} - void on_day_of_month_space(numeric_system) {} + void on_dec0_week_of_year(numeric_system, pad_type) {} + void on_dec1_week_of_year(numeric_system, pad_type) {} + void on_iso_week_of_year(numeric_system, pad_type) {} + void on_day_of_month(numeric_system, pad_type) {} + + void on_day_of_year() { + if (handle_nan_inf()) return; + write(days(), 0); + } void on_24_hour(numeric_system ns, pad_type pad) { if (handle_nan_inf()) return; @@ -1978,7 +2005,7 @@ struct chrono_formatter { on_24_hour_time(); *out++ = ':'; if (handle_nan_inf()) return; - on_second(numeric_system::standard, pad_type::unspecified); + on_second(numeric_system::standard, pad_type::zero); } void on_am_pm() { @@ -1997,130 +2024,279 @@ struct chrono_formatter { } }; -FMT_END_DETAIL_NAMESPACE +} // namespace detail #if defined(__cpp_lib_chrono) && __cpp_lib_chrono >= 201907 using weekday = std::chrono::weekday; +using day = std::chrono::day; +using month = std::chrono::month; +using year = std::chrono::year; +using year_month_day = std::chrono::year_month_day; #else // A fallback version of weekday. class weekday { private: - unsigned char value; + unsigned char value_; public: weekday() = default; - explicit constexpr weekday(unsigned wd) noexcept - : value(static_cast<unsigned char>(wd != 7 ? wd : 0)) {} - constexpr unsigned c_encoding() const noexcept { return value; } + constexpr explicit weekday(unsigned wd) noexcept + : value_(static_cast<unsigned char>(wd != 7 ? wd : 0)) {} + constexpr auto c_encoding() const noexcept -> unsigned { return value_; } +}; + +class day { + private: + unsigned char value_; + + public: + day() = default; + constexpr explicit day(unsigned d) noexcept + : value_(static_cast<unsigned char>(d)) {} + constexpr explicit operator unsigned() const noexcept { return value_; } +}; + +class month { + private: + unsigned char value_; + + public: + month() = default; + constexpr explicit month(unsigned m) noexcept + : value_(static_cast<unsigned char>(m)) {} + constexpr explicit operator unsigned() const noexcept { return value_; } +}; + +class year { + private: + int value_; + + public: + year() = default; + constexpr explicit year(int y) noexcept : value_(y) {} + constexpr explicit operator int() const noexcept { return value_; } }; -class year_month_day {}; +class year_month_day { + private: + fmt::year year_; + fmt::month month_; + fmt::day day_; + + public: + year_month_day() = default; + constexpr year_month_day(const year& y, const month& m, const day& d) noexcept + : year_(y), month_(m), day_(d) {} + constexpr auto year() const noexcept -> fmt::year { return year_; } + constexpr auto month() const noexcept -> fmt::month { return month_; } + constexpr auto day() const noexcept -> fmt::day { return day_; } +}; #endif -// A rudimentary weekday formatter. -template <typename Char> struct formatter<weekday, Char> { +template <typename Char> +struct formatter<weekday, Char> : private formatter<std::tm, Char> { private: - bool localized = false; + bool localized_ = false; + bool use_tm_formatter_ = false; public: FMT_CONSTEXPR auto parse(basic_format_parse_context<Char>& ctx) -> decltype(ctx.begin()) { - auto begin = ctx.begin(), end = ctx.end(); - if (begin != end && *begin == 'L') { - ++begin; - localized = true; + auto it = ctx.begin(), end = ctx.end(); + if (it != end && *it == 'L') { + ++it; + localized_ = true; + return it; } - return begin; + use_tm_formatter_ = it != end && *it != '}'; + return use_tm_formatter_ ? formatter<std::tm, Char>::parse(ctx) : it; } template <typename FormatContext> auto format(weekday wd, FormatContext& ctx) const -> decltype(ctx.out()) { auto time = std::tm(); time.tm_wday = static_cast<int>(wd.c_encoding()); - detail::get_locale loc(localized, ctx.locale()); + if (use_tm_formatter_) return formatter<std::tm, Char>::format(time, ctx); + detail::get_locale loc(localized_, ctx.locale()); auto w = detail::tm_writer<decltype(ctx.out()), Char>(loc, ctx.out(), time); w.on_abbr_weekday(); return w.out(); } }; -template <typename Rep, typename Period, typename Char> -struct formatter<std::chrono::duration<Rep, Period>, Char> { +template <typename Char> +struct formatter<day, Char> : private formatter<std::tm, Char> { private: - format_specs<Char> specs; - int precision = -1; - using arg_ref_type = detail::arg_ref<Char>; - arg_ref_type width_ref; - arg_ref_type precision_ref; - bool localized = false; - basic_string_view<Char> format_str; - using duration = std::chrono::duration<Rep, Period>; + bool use_tm_formatter_ = false; - using iterator = typename basic_format_parse_context<Char>::iterator; - struct parse_range { - iterator begin; - iterator end; - }; - - FMT_CONSTEXPR parse_range do_parse(basic_format_parse_context<Char>& ctx) { - auto begin = ctx.begin(), end = ctx.end(); - if (begin == end || *begin == '}') return {begin, begin}; + public: + FMT_CONSTEXPR auto parse(basic_format_parse_context<Char>& ctx) + -> decltype(ctx.begin()) { + auto it = ctx.begin(), end = ctx.end(); + use_tm_formatter_ = it != end && *it != '}'; + return use_tm_formatter_ ? formatter<std::tm, Char>::parse(ctx) : it; + } - begin = detail::parse_align(begin, end, specs); - if (begin == end) return {begin, begin}; + template <typename FormatContext> + auto format(day d, FormatContext& ctx) const -> decltype(ctx.out()) { + auto time = std::tm(); + time.tm_mday = static_cast<int>(static_cast<unsigned>(d)); + if (use_tm_formatter_) return formatter<std::tm, Char>::format(time, ctx); + detail::get_locale loc(false, ctx.locale()); + auto w = detail::tm_writer<decltype(ctx.out()), Char>(loc, ctx.out(), time); + w.on_day_of_month(detail::numeric_system::standard, detail::pad_type::zero); + return w.out(); + } +}; - begin = detail::parse_dynamic_spec(begin, end, specs.width, width_ref, ctx); - if (begin == end) return {begin, begin}; +template <typename Char> +struct formatter<month, Char> : private formatter<std::tm, Char> { + private: + bool localized_ = false; + bool use_tm_formatter_ = false; - auto checker = detail::chrono_format_checker(); - if (*begin == '.') { - checker.has_precision_integral = !std::is_floating_point<Rep>::value; - begin = - detail::parse_precision(begin, end, precision, precision_ref, ctx); - } - if (begin != end && *begin == 'L') { - ++begin; - localized = true; + public: + FMT_CONSTEXPR auto parse(basic_format_parse_context<Char>& ctx) + -> decltype(ctx.begin()) { + auto it = ctx.begin(), end = ctx.end(); + if (it != end && *it == 'L') { + ++it; + localized_ = true; + return it; } - end = detail::parse_chrono_format(begin, end, checker); - return {begin, end}; + use_tm_formatter_ = it != end && *it != '}'; + return use_tm_formatter_ ? formatter<std::tm, Char>::parse(ctx) : it; } + template <typename FormatContext> + auto format(month m, FormatContext& ctx) const -> decltype(ctx.out()) { + auto time = std::tm(); + time.tm_mon = static_cast<int>(static_cast<unsigned>(m)) - 1; + if (use_tm_formatter_) return formatter<std::tm, Char>::format(time, ctx); + detail::get_locale loc(localized_, ctx.locale()); + auto w = detail::tm_writer<decltype(ctx.out()), Char>(loc, ctx.out(), time); + w.on_abbr_month(); + return w.out(); + } +}; + +template <typename Char> +struct formatter<year, Char> : private formatter<std::tm, Char> { + private: + bool use_tm_formatter_ = false; + public: FMT_CONSTEXPR auto parse(basic_format_parse_context<Char>& ctx) -> decltype(ctx.begin()) { - auto range = do_parse(ctx); - format_str = basic_string_view<Char>( - &*range.begin, detail::to_unsigned(range.end - range.begin)); - return range.end; + auto it = ctx.begin(), end = ctx.end(); + use_tm_formatter_ = it != end && *it != '}'; + return use_tm_formatter_ ? formatter<std::tm, Char>::parse(ctx) : it; } template <typename FormatContext> - auto format(const duration& d, FormatContext& ctx) const + auto format(year y, FormatContext& ctx) const -> decltype(ctx.out()) { + auto time = std::tm(); + time.tm_year = static_cast<int>(y) - 1900; + if (use_tm_formatter_) return formatter<std::tm, Char>::format(time, ctx); + detail::get_locale loc(false, ctx.locale()); + auto w = detail::tm_writer<decltype(ctx.out()), Char>(loc, ctx.out(), time); + w.on_year(detail::numeric_system::standard); + return w.out(); + } +}; + +template <typename Char> +struct formatter<year_month_day, Char> : private formatter<std::tm, Char> { + private: + bool use_tm_formatter_ = false; + + public: + FMT_CONSTEXPR auto parse(basic_format_parse_context<Char>& ctx) + -> decltype(ctx.begin()) { + auto it = ctx.begin(), end = ctx.end(); + use_tm_formatter_ = it != end && *it != '}'; + return use_tm_formatter_ ? formatter<std::tm, Char>::parse(ctx) : it; + } + + template <typename FormatContext> + auto format(year_month_day val, FormatContext& ctx) const + -> decltype(ctx.out()) { + auto time = std::tm(); + time.tm_year = static_cast<int>(val.year()) - 1900; + time.tm_mon = static_cast<int>(static_cast<unsigned>(val.month())) - 1; + time.tm_mday = static_cast<int>(static_cast<unsigned>(val.day())); + if (use_tm_formatter_) return formatter<std::tm, Char>::format(time, ctx); + detail::get_locale loc(true, ctx.locale()); + auto w = detail::tm_writer<decltype(ctx.out()), Char>(loc, ctx.out(), time); + w.on_iso_date(); + return w.out(); + } +}; + +template <typename Rep, typename Period, typename Char> +struct formatter<std::chrono::duration<Rep, Period>, Char> { + private: + format_specs specs_; + detail::arg_ref<Char> width_ref_; + detail::arg_ref<Char> precision_ref_; + bool localized_ = false; + basic_string_view<Char> format_str_; + + public: + FMT_CONSTEXPR auto parse(basic_format_parse_context<Char>& ctx) + -> decltype(ctx.begin()) { + auto it = ctx.begin(), end = ctx.end(); + if (it == end || *it == '}') return it; + + it = detail::parse_align(it, end, specs_); + if (it == end) return it; + + it = detail::parse_dynamic_spec(it, end, specs_.width, width_ref_, ctx); + if (it == end) return it; + + auto checker = detail::chrono_format_checker(); + if (*it == '.') { + checker.has_precision_integral = !std::is_floating_point<Rep>::value; + it = detail::parse_precision(it, end, specs_.precision, precision_ref_, + ctx); + } + if (it != end && *it == 'L') { + localized_ = true; + ++it; + } + end = detail::parse_chrono_format(it, end, checker); + format_str_ = {it, detail::to_unsigned(end - it)}; + return end; + } + + template <typename FormatContext> + auto format(std::chrono::duration<Rep, Period> d, FormatContext& ctx) const -> decltype(ctx.out()) { - auto specs_copy = specs; - auto precision_copy = precision; - auto begin = format_str.begin(), end = format_str.end(); + auto specs = specs_; + auto precision = specs.precision; + specs.precision = -1; + auto begin = format_str_.begin(), end = format_str_.end(); // As a possible future optimization, we could avoid extra copying if width // is not specified. - basic_memory_buffer<Char> buf; + auto buf = basic_memory_buffer<Char>(); auto out = std::back_inserter(buf); - detail::handle_dynamic_spec<detail::width_checker>(specs_copy.width, - width_ref, ctx); - detail::handle_dynamic_spec<detail::precision_checker>(precision_copy, - precision_ref, ctx); + detail::handle_dynamic_spec<detail::width_checker>(specs.width, width_ref_, + ctx); + detail::handle_dynamic_spec<detail::precision_checker>(precision, + precision_ref_, ctx); if (begin == end || *begin == '}') { - out = detail::format_duration_value<Char>(out, d.count(), precision_copy); + out = detail::format_duration_value<Char>(out, d.count(), precision); detail::format_duration_unit<Char, Period>(out); } else { - detail::chrono_formatter<FormatContext, decltype(out), Rep, Period> f( - ctx, out, d); - f.precision = precision_copy; - f.localized = localized; + using chrono_formatter = + detail::chrono_formatter<FormatContext, decltype(out), Rep, Period>; + auto f = chrono_formatter(ctx, out, d); + f.precision = precision; + f.localized = localized_; detail::parse_chrono_format(begin, end, f); } return detail::write( - ctx.out(), basic_string_view<Char>(buf.data(), buf.size()), specs_copy); + ctx.out(), basic_string_view<Char>(buf.data(), buf.size()), specs); } }; @@ -2128,34 +2304,32 @@ template <typename Char, typename Duration> struct formatter<std::chrono::time_point<std::chrono::system_clock, Duration>, Char> : formatter<std::tm, Char> { FMT_CONSTEXPR formatter() { - this->format_str = detail::string_literal<Char, '%', 'F', ' ', '%', 'T'>{}; + this->format_str_ = detail::string_literal<Char, '%', 'F', ' ', '%', 'T'>{}; } template <typename FormatContext> auto format(std::chrono::time_point<std::chrono::system_clock, Duration> val, FormatContext& ctx) const -> decltype(ctx.out()) { + std::tm tm = gmtime(val); using period = typename Duration::period; - if (period::num != 1 || period::den != 1 || - std::is_floating_point<typename Duration::rep>::value) { - const auto epoch = val.time_since_epoch(); - auto subsecs = std::chrono::duration_cast<Duration>( - epoch - std::chrono::duration_cast<std::chrono::seconds>(epoch)); - - if (subsecs.count() < 0) { - auto second = std::chrono::seconds(1); - if (epoch.count() < ((Duration::min)() + second).count()) - FMT_THROW(format_error("duration is too small")); - subsecs += second; - val -= second; - } - - return formatter<std::tm, Char>::do_format( - gmtime(std::chrono::time_point_cast<std::chrono::seconds>(val)), ctx, - &subsecs); + if (detail::const_check( + period::num == 1 && period::den == 1 && + !std::is_floating_point<typename Duration::rep>::value)) { + return formatter<std::tm, Char>::format(tm, ctx); } - - return formatter<std::tm, Char>::format( - gmtime(std::chrono::time_point_cast<std::chrono::seconds>(val)), ctx); + Duration epoch = val.time_since_epoch(); + Duration subsecs = detail::fmt_duration_cast<Duration>( + epoch - detail::fmt_duration_cast<std::chrono::seconds>(epoch)); + if (subsecs.count() < 0) { + auto second = + detail::fmt_duration_cast<Duration>(std::chrono::seconds(1)); + if (tm.tm_sec != 0) + --tm.tm_sec; + else + tm = gmtime(val - second); + subsecs += detail::fmt_duration_cast<Duration>(std::chrono::seconds(1)); + } + return formatter<std::tm, Char>::do_format(tm, ctx, &subsecs); } }; @@ -2164,7 +2338,7 @@ template <typename Char, typename Duration> struct formatter<std::chrono::local_time<Duration>, Char> : formatter<std::tm, Char> { FMT_CONSTEXPR formatter() { - this->format_str = detail::string_literal<Char, '%', 'F', ' ', '%', 'T'>{}; + this->format_str_ = detail::string_literal<Char, '%', 'F', ' ', '%', 'T'>{}; } template <typename FormatContext> @@ -2174,17 +2348,13 @@ struct formatter<std::chrono::local_time<Duration>, Char> if (period::num != 1 || period::den != 1 || std::is_floating_point<typename Duration::rep>::value) { const auto epoch = val.time_since_epoch(); - const auto subsecs = std::chrono::duration_cast<Duration>( - epoch - std::chrono::duration_cast<std::chrono::seconds>(epoch)); + const auto subsecs = detail::fmt_duration_cast<Duration>( + epoch - detail::fmt_duration_cast<std::chrono::seconds>(epoch)); - return formatter<std::tm, Char>::do_format( - localtime(std::chrono::time_point_cast<std::chrono::seconds>(val)), - ctx, &subsecs); + return formatter<std::tm, Char>::do_format(localtime(val), ctx, &subsecs); } - return formatter<std::tm, Char>::format( - localtime(std::chrono::time_point_cast<std::chrono::seconds>(val)), - ctx); + return formatter<std::tm, Char>::format(localtime(val), ctx); } }; #endif @@ -2207,51 +2377,46 @@ struct formatter<std::chrono::time_point<std::chrono::utc_clock, Duration>, template <typename Char> struct formatter<std::tm, Char> { private: - format_specs<Char> specs; - detail::arg_ref<Char> width_ref; + format_specs specs_; + detail::arg_ref<Char> width_ref_; protected: - basic_string_view<Char> format_str; - - FMT_CONSTEXPR auto do_parse(basic_format_parse_context<Char>& ctx) - -> decltype(ctx.begin()) { - auto begin = ctx.begin(), end = ctx.end(); - if (begin == end || *begin == '}') return begin; - - begin = detail::parse_align(begin, end, specs); - if (begin == end) return end; - - begin = detail::parse_dynamic_spec(begin, end, specs.width, width_ref, ctx); - if (begin == end) return end; - - end = detail::parse_chrono_format(begin, end, detail::tm_format_checker()); - // Replace default format_str only if the new spec is not empty. - if (end != begin) format_str = {begin, detail::to_unsigned(end - begin)}; - return end; - } + basic_string_view<Char> format_str_; template <typename FormatContext, typename Duration> auto do_format(const std::tm& tm, FormatContext& ctx, const Duration* subsecs) const -> decltype(ctx.out()) { - auto specs_copy = specs; - basic_memory_buffer<Char> buf; + auto specs = specs_; + auto buf = basic_memory_buffer<Char>(); auto out = std::back_inserter(buf); - detail::handle_dynamic_spec<detail::width_checker>(specs_copy.width, - width_ref, ctx); + detail::handle_dynamic_spec<detail::width_checker>(specs.width, width_ref_, + ctx); - const auto loc_ref = ctx.locale(); + auto loc_ref = ctx.locale(); detail::get_locale loc(static_cast<bool>(loc_ref), loc_ref); auto w = detail::tm_writer<decltype(out), Char, Duration>(loc, out, tm, subsecs); - detail::parse_chrono_format(format_str.begin(), format_str.end(), w); + detail::parse_chrono_format(format_str_.begin(), format_str_.end(), w); return detail::write( - ctx.out(), basic_string_view<Char>(buf.data(), buf.size()), specs_copy); + ctx.out(), basic_string_view<Char>(buf.data(), buf.size()), specs); } public: FMT_CONSTEXPR auto parse(basic_format_parse_context<Char>& ctx) -> decltype(ctx.begin()) { - return this->do_parse(ctx); + auto it = ctx.begin(), end = ctx.end(); + if (it == end || *it == '}') return it; + + it = detail::parse_align(it, end, specs_); + if (it == end) return it; + + it = detail::parse_dynamic_spec(it, end, specs_.width, width_ref_, ctx); + if (it == end) return it; + + end = detail::parse_chrono_format(it, end, detail::tm_format_checker()); + // Replace the default format_str only if the new spec is not empty. + if (end != it) format_str_ = {it, detail::to_unsigned(end - it)}; + return end; } template <typename FormatContext> diff --git a/contrib/fmt/include/fmt/color.h b/contrib/fmt/include/fmt/color.h index d175448ab..f0e9dd94e 100644 --- a/contrib/fmt/include/fmt/color.h +++ b/contrib/fmt/include/fmt/color.h @@ -203,7 +203,7 @@ struct rgb { uint8_t b; }; -FMT_BEGIN_DETAIL_NAMESPACE +namespace detail { // color is a struct of either a rgb color or a terminal color. struct color_type { @@ -225,22 +225,21 @@ struct color_type { uint32_t rgb_color; } value; }; +} // namespace detail -FMT_END_DETAIL_NAMESPACE - -/** A text style consisting of foreground and background colors and emphasis. */ +/// A text style consisting of foreground and background colors and emphasis. class text_style { public: FMT_CONSTEXPR text_style(emphasis em = emphasis()) noexcept : set_foreground_color(), set_background_color(), ems(em) {} - FMT_CONSTEXPR text_style& operator|=(const text_style& rhs) { + FMT_CONSTEXPR auto operator|=(const text_style& rhs) -> text_style& { if (!set_foreground_color) { set_foreground_color = rhs.set_foreground_color; foreground_color = rhs.foreground_color; } else if (rhs.set_foreground_color) { if (!foreground_color.is_rgb || !rhs.foreground_color.is_rgb) - FMT_THROW(format_error("can't OR a terminal color")); + report_error("can't OR a terminal color"); foreground_color.value.rgb_color |= rhs.foreground_color.value.rgb_color; } @@ -249,7 +248,7 @@ class text_style { background_color = rhs.background_color; } else if (rhs.set_background_color) { if (!background_color.is_rgb || !rhs.background_color.is_rgb) - FMT_THROW(format_error("can't OR a terminal color")); + report_error("can't OR a terminal color"); background_color.value.rgb_color |= rhs.background_color.value.rgb_color; } @@ -258,29 +257,29 @@ class text_style { return *this; } - friend FMT_CONSTEXPR text_style operator|(text_style lhs, - const text_style& rhs) { + friend FMT_CONSTEXPR auto operator|(text_style lhs, const text_style& rhs) + -> text_style { return lhs |= rhs; } - FMT_CONSTEXPR bool has_foreground() const noexcept { + FMT_CONSTEXPR auto has_foreground() const noexcept -> bool { return set_foreground_color; } - FMT_CONSTEXPR bool has_background() const noexcept { + FMT_CONSTEXPR auto has_background() const noexcept -> bool { return set_background_color; } - FMT_CONSTEXPR bool has_emphasis() const noexcept { + FMT_CONSTEXPR auto has_emphasis() const noexcept -> bool { return static_cast<uint8_t>(ems) != 0; } - FMT_CONSTEXPR detail::color_type get_foreground() const noexcept { + FMT_CONSTEXPR auto get_foreground() const noexcept -> detail::color_type { FMT_ASSERT(has_foreground(), "no foreground specified for this style"); return foreground_color; } - FMT_CONSTEXPR detail::color_type get_background() const noexcept { + FMT_CONSTEXPR auto get_background() const noexcept -> detail::color_type { FMT_ASSERT(has_background(), "no background specified for this style"); return background_color; } - FMT_CONSTEXPR emphasis get_emphasis() const noexcept { + FMT_CONSTEXPR auto get_emphasis() const noexcept -> emphasis { FMT_ASSERT(has_emphasis(), "no emphasis specified for this style"); return ems; } @@ -298,9 +297,11 @@ class text_style { } } - friend FMT_CONSTEXPR text_style fg(detail::color_type foreground) noexcept; + friend FMT_CONSTEXPR auto fg(detail::color_type foreground) noexcept + -> text_style; - friend FMT_CONSTEXPR text_style bg(detail::color_type background) noexcept; + friend FMT_CONSTEXPR auto bg(detail::color_type background) noexcept + -> text_style; detail::color_type foreground_color; detail::color_type background_color; @@ -309,21 +310,24 @@ class text_style { emphasis ems; }; -/** Creates a text style from the foreground (text) color. */ -FMT_CONSTEXPR inline text_style fg(detail::color_type foreground) noexcept { +/// Creates a text style from the foreground (text) color. +FMT_CONSTEXPR inline auto fg(detail::color_type foreground) noexcept + -> text_style { return text_style(true, foreground); } -/** Creates a text style from the background color. */ -FMT_CONSTEXPR inline text_style bg(detail::color_type background) noexcept { +/// Creates a text style from the background color. +FMT_CONSTEXPR inline auto bg(detail::color_type background) noexcept + -> text_style { return text_style(false, background); } -FMT_CONSTEXPR inline text_style operator|(emphasis lhs, emphasis rhs) noexcept { +FMT_CONSTEXPR inline auto operator|(emphasis lhs, emphasis rhs) noexcept + -> text_style { return text_style(lhs) | rhs; } -FMT_BEGIN_DETAIL_NAMESPACE +namespace detail { template <typename Char> struct ansi_color_escape { FMT_CONSTEXPR ansi_color_escape(detail::color_type text_color, @@ -385,9 +389,9 @@ template <typename Char> struct ansi_color_escape { } FMT_CONSTEXPR operator const Char*() const noexcept { return buffer; } - FMT_CONSTEXPR const Char* begin() const noexcept { return buffer; } - FMT_CONSTEXPR_CHAR_TRAITS const Char* end() const noexcept { - return buffer + std::char_traits<Char>::length(buffer); + FMT_CONSTEXPR auto begin() const noexcept -> const Char* { return buffer; } + FMT_CONSTEXPR20 auto end() const noexcept -> const Char* { + return buffer + basic_string_view<Char>(buffer).size(); } private: @@ -401,25 +405,27 @@ template <typename Char> struct ansi_color_escape { out[2] = static_cast<Char>('0' + c % 10); out[3] = static_cast<Char>(delimiter); } - static FMT_CONSTEXPR bool has_emphasis(emphasis em, emphasis mask) noexcept { + static FMT_CONSTEXPR auto has_emphasis(emphasis em, emphasis mask) noexcept + -> bool { return static_cast<uint8_t>(em) & static_cast<uint8_t>(mask); } }; template <typename Char> -FMT_CONSTEXPR ansi_color_escape<Char> make_foreground_color( - detail::color_type foreground) noexcept { +FMT_CONSTEXPR auto make_foreground_color(detail::color_type foreground) noexcept + -> ansi_color_escape<Char> { return ansi_color_escape<Char>(foreground, "\x1b[38;2;"); } template <typename Char> -FMT_CONSTEXPR ansi_color_escape<Char> make_background_color( - detail::color_type background) noexcept { +FMT_CONSTEXPR auto make_background_color(detail::color_type background) noexcept + -> ansi_color_escape<Char> { return ansi_color_escape<Char>(background, "\x1b[48;2;"); } template <typename Char> -FMT_CONSTEXPR ansi_color_escape<Char> make_emphasis(emphasis em) noexcept { +FMT_CONSTEXPR auto make_emphasis(emphasis em) noexcept + -> ansi_color_escape<Char> { return ansi_color_escape<Char>(em); } @@ -428,15 +434,16 @@ template <typename Char> inline void reset_color(buffer<Char>& buffer) { buffer.append(reset_color.begin(), reset_color.end()); } -template <typename T> struct styled_arg { +template <typename T> struct styled_arg : detail::view { const T& value; text_style style; + styled_arg(const T& v, text_style s) : value(v), style(s) {} }; template <typename Char> -void vformat_to(buffer<Char>& buf, const text_style& ts, - basic_string_view<Char> format_str, - basic_format_args<buffer_context<type_identity_t<Char>>> args) { +void vformat_to( + buffer<Char>& buf, const text_style& ts, basic_string_view<Char> format_str, + basic_format_args<buffered_context<type_identity_t<Char>>> args) { bool has_style = false; if (ts.has_emphasis()) { has_style = true; @@ -457,120 +464,94 @@ void vformat_to(buffer<Char>& buf, const text_style& ts, if (has_style) detail::reset_color<Char>(buf); } -FMT_END_DETAIL_NAMESPACE +} // namespace detail -inline void vprint(std::FILE* f, const text_style& ts, string_view fmt, +inline void vprint(FILE* f, const text_style& ts, string_view fmt, format_args args) { - // Legacy wide streams are not supported. auto buf = memory_buffer(); detail::vformat_to(buf, ts, fmt, args); - if (detail::is_utf8()) { - detail::print(f, string_view(buf.begin(), buf.size())); - return; - } - buf.push_back('\0'); - int result = std::fputs(buf.data(), f); - if (result < 0) - FMT_THROW(system_error(errno, FMT_STRING("cannot write to file"))); + print(f, FMT_STRING("{}"), string_view(buf.begin(), buf.size())); } /** - \rst - Formats a string and prints it to the specified file stream using ANSI - escape sequences to specify text formatting. - - **Example**:: - - fmt::print(fmt::emphasis::bold | fg(fmt::color::red), - "Elapsed time: {0:.2f} seconds", 1.23); - \endrst + * Formats a string and prints it to the specified file stream using ANSI + * escape sequences to specify text formatting. + * + * **Example**: + * + * fmt::print(fmt::emphasis::bold | fg(fmt::color::red), + * "Elapsed time: {0:.2f} seconds", 1.23); */ -template <typename S, typename... Args, - FMT_ENABLE_IF(detail::is_string<S>::value)> -void print(std::FILE* f, const text_style& ts, const S& format_str, - const Args&... args) { - vprint(f, ts, format_str, - fmt::make_format_args<buffer_context<char_t<S>>>(args...)); +template <typename... T> +void print(FILE* f, const text_style& ts, format_string<T...> fmt, + T&&... args) { + vprint(f, ts, fmt, fmt::make_format_args(args...)); } /** - \rst - Formats a string and prints it to stdout using ANSI escape sequences to - specify text formatting. - - **Example**:: - - fmt::print(fmt::emphasis::bold | fg(fmt::color::red), - "Elapsed time: {0:.2f} seconds", 1.23); - \endrst + * Formats a string and prints it to stdout using ANSI escape sequences to + * specify text formatting. + * + * **Example**: + * + * fmt::print(fmt::emphasis::bold | fg(fmt::color::red), + * "Elapsed time: {0:.2f} seconds", 1.23); */ -template <typename S, typename... Args, - FMT_ENABLE_IF(detail::is_string<S>::value)> -void print(const text_style& ts, const S& format_str, const Args&... args) { - return print(stdout, ts, format_str, args...); +template <typename... T> +void print(const text_style& ts, format_string<T...> fmt, T&&... args) { + return print(stdout, ts, fmt, std::forward<T>(args)...); } -template <typename S, typename Char = char_t<S>> -inline std::basic_string<Char> vformat( - const text_style& ts, const S& format_str, - basic_format_args<buffer_context<type_identity_t<Char>>> args) { - basic_memory_buffer<Char> buf; - detail::vformat_to(buf, ts, detail::to_string_view(format_str), args); +inline auto vformat(const text_style& ts, string_view fmt, format_args args) + -> std::string { + auto buf = memory_buffer(); + detail::vformat_to(buf, ts, fmt, args); return fmt::to_string(buf); } /** - \rst - Formats arguments and returns the result as a string using ANSI - escape sequences to specify text formatting. - - **Example**:: - - #include <fmt/color.h> - std::string message = fmt::format(fmt::emphasis::bold | fg(fmt::color::red), - "The answer is {}", 42); - \endrst -*/ -template <typename S, typename... Args, typename Char = char_t<S>> -inline std::basic_string<Char> format(const text_style& ts, const S& format_str, - const Args&... args) { - return fmt::vformat(ts, detail::to_string_view(format_str), - fmt::make_format_args<buffer_context<Char>>(args...)); + * Formats arguments and returns the result as a string using ANSI escape + * sequences to specify text formatting. + * + * **Example**: + * + * ``` + * #include <fmt/color.h> + * std::string message = fmt::format(fmt::emphasis::bold | fg(fmt::color::red), + * "The answer is {}", 42); + * ``` + */ +template <typename... T> +inline auto format(const text_style& ts, format_string<T...> fmt, T&&... args) + -> std::string { + return fmt::vformat(ts, fmt, fmt::make_format_args(args...)); } -/** - Formats a string with the given text_style and writes the output to ``out``. - */ -template <typename OutputIt, typename Char, - FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value)> -OutputIt vformat_to( - OutputIt out, const text_style& ts, basic_string_view<Char> format_str, - basic_format_args<buffer_context<type_identity_t<Char>>> args) { - auto&& buf = detail::get_buffer<Char>(out); - detail::vformat_to(buf, ts, format_str, args); +/// Formats a string with the given text_style and writes the output to `out`. +template <typename OutputIt, + FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, char>::value)> +auto vformat_to(OutputIt out, const text_style& ts, string_view fmt, + format_args args) -> OutputIt { + auto&& buf = detail::get_buffer<char>(out); + detail::vformat_to(buf, ts, fmt, args); return detail::get_iterator(buf, out); } /** - \rst - Formats arguments with the given text_style, writes the result to the output - iterator ``out`` and returns the iterator past the end of the output range. - - **Example**:: - - std::vector<char> out; - fmt::format_to(std::back_inserter(out), - fmt::emphasis::bold | fg(fmt::color::red), "{}", 42); - \endrst -*/ -template <typename OutputIt, typename S, typename... Args, - bool enable = detail::is_output_iterator<OutputIt, char_t<S>>::value&& - detail::is_string<S>::value> -inline auto format_to(OutputIt out, const text_style& ts, const S& format_str, - Args&&... args) -> - typename std::enable_if<enable, OutputIt>::type { - return vformat_to(out, ts, detail::to_string_view(format_str), - fmt::make_format_args<buffer_context<char_t<S>>>(args...)); + * Formats arguments with the given text style, writes the result to the output + * iterator `out` and returns the iterator past the end of the output range. + * + * **Example**: + * + * std::vector<char> out; + * fmt::format_to(std::back_inserter(out), + * fmt::emphasis::bold | fg(fmt::color::red), "{}", 42); + */ +template <typename OutputIt, typename... T, + FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, char>::value)> +inline auto format_to(OutputIt out, const text_style& ts, + format_string<T...> fmt, T&&... args) -> OutputIt { + return vformat_to(out, ts, fmt, fmt::make_format_args(args...)); } template <typename T, typename Char> @@ -610,16 +591,14 @@ struct formatter<detail::styled_arg<T>, Char> : formatter<T, Char> { }; /** - \rst - Returns an argument that will be formatted using ANSI escape sequences, - to be used in a formatting function. - - **Example**:: - - fmt::print("Elapsed time: {0:.2f} seconds", - fmt::styled(1.23, fmt::fg(fmt::color::green) | - fmt::bg(fmt::color::blue))); - \endrst + * Returns an argument that will be formatted using ANSI escape sequences, + * to be used in a formatting function. + * + * **Example**: + * + * fmt::print("Elapsed time: {0:.2f} seconds", + * fmt::styled(1.23, fmt::fg(fmt::color::green) | + * fmt::bg(fmt::color::blue))); */ template <typename T> FMT_CONSTEXPR auto styled(const T& value, text_style ts) diff --git a/contrib/fmt/include/fmt/compile.h b/contrib/fmt/include/fmt/compile.h index 94e13c02d..b2afc2c30 100644 --- a/contrib/fmt/include/fmt/compile.h +++ b/contrib/fmt/include/fmt/compile.h @@ -8,117 +8,41 @@ #ifndef FMT_COMPILE_H_ #define FMT_COMPILE_H_ +#ifndef FMT_MODULE +# include <iterator> // std::back_inserter +#endif + #include "format.h" FMT_BEGIN_NAMESPACE + +// A compile-time string which is compiled into fast formatting code. +FMT_EXPORT class compiled_string {}; + namespace detail { -template <typename Char, typename InputIt> -FMT_CONSTEXPR inline counting_iterator copy_str(InputIt begin, InputIt end, - counting_iterator it) { +template <typename T, typename InputIt> +FMT_CONSTEXPR inline auto copy(InputIt begin, InputIt end, counting_iterator it) + -> counting_iterator { return it + (end - begin); } -template <typename OutputIt> class truncating_iterator_base { - protected: - OutputIt out_; - size_t limit_; - size_t count_ = 0; - - truncating_iterator_base() : out_(), limit_(0) {} - - truncating_iterator_base(OutputIt out, size_t limit) - : out_(out), limit_(limit) {} - - public: - using iterator_category = std::output_iterator_tag; - using value_type = typename std::iterator_traits<OutputIt>::value_type; - using difference_type = std::ptrdiff_t; - using pointer = void; - using reference = void; - FMT_UNCHECKED_ITERATOR(truncating_iterator_base); - - OutputIt base() const { return out_; } - size_t count() const { return count_; } -}; - -// An output iterator that truncates the output and counts the number of objects -// written to it. -template <typename OutputIt, - typename Enable = typename std::is_void< - typename std::iterator_traits<OutputIt>::value_type>::type> -class truncating_iterator; - -template <typename OutputIt> -class truncating_iterator<OutputIt, std::false_type> - : public truncating_iterator_base<OutputIt> { - mutable typename truncating_iterator_base<OutputIt>::value_type blackhole_; - - public: - using value_type = typename truncating_iterator_base<OutputIt>::value_type; - - truncating_iterator() = default; - - truncating_iterator(OutputIt out, size_t limit) - : truncating_iterator_base<OutputIt>(out, limit) {} - - truncating_iterator& operator++() { - if (this->count_++ < this->limit_) ++this->out_; - return *this; - } - - truncating_iterator operator++(int) { - auto it = *this; - ++*this; - return it; - } - - value_type& operator*() const { - return this->count_ < this->limit_ ? *this->out_ : blackhole_; - } -}; - -template <typename OutputIt> -class truncating_iterator<OutputIt, std::true_type> - : public truncating_iterator_base<OutputIt> { - public: - truncating_iterator() = default; - - truncating_iterator(OutputIt out, size_t limit) - : truncating_iterator_base<OutputIt>(out, limit) {} - - template <typename T> truncating_iterator& operator=(T val) { - if (this->count_++ < this->limit_) *this->out_++ = val; - return *this; - } - - truncating_iterator& operator++() { return *this; } - truncating_iterator& operator++(int) { return *this; } - truncating_iterator& operator*() { return *this; } -}; - -// A compile-time string which is compiled into fast formatting code. -class compiled_string {}; - template <typename S> struct is_compiled_string : std::is_base_of<compiled_string, S> {}; /** - \rst - Converts a string literal *s* into a format string that will be parsed at - compile time and converted into efficient formatting code. Requires C++17 - ``constexpr if`` compiler support. - - **Example**:: - - // Converts 42 into std::string using the most efficient method and no - // runtime format string processing. - std::string s = fmt::format(FMT_COMPILE("{}"), 42); - \endrst + * Converts a string literal `s` into a format string that will be parsed at + * compile time and converted into efficient formatting code. Requires C++17 + * `constexpr if` compiler support. + * + * **Example**: + * + * // Converts 42 into std::string using the most efficient method and no + * // runtime format string processing. + * std::string s = fmt::format(FMT_COMPILE("{}"), 42); */ #if defined(__cpp_if_constexpr) && defined(__cpp_return_type_deduction) -# define FMT_COMPILE(s) \ - FMT_STRING_IMPL(s, fmt::detail::compiled_string, explicit) +# define FMT_COMPILE(s) FMT_STRING_IMPL(s, fmt::compiled_string, explicit) #else # define FMT_COMPILE(s) FMT_STRING(s) #endif @@ -135,7 +59,7 @@ struct udl_compiled_string : compiled_string { #endif template <typename T, typename... Tail> -const T& first(const T& value, const Tail&...) { +auto first(const T& value, const Tail&...) -> const T& { return value; } @@ -196,7 +120,8 @@ template <typename Char> struct code_unit { template <typename OutputIt, typename... Args> constexpr OutputIt format(OutputIt out, const Args&...) const { - return write<Char>(out, value); + *out++ = value; + return out; } }; @@ -220,7 +145,12 @@ template <typename Char, typename T, int N> struct field { template <typename OutputIt, typename... Args> constexpr OutputIt format(OutputIt out, const Args&... args) const { - return write<Char>(out, get_arg_checked<T, N>(args...)); + const T& arg = get_arg_checked<T, N>(args...); + if constexpr (std::is_convertible<T, basic_string_view<Char>>::value) { + auto s = basic_string_view<Char>(arg); + return copy<Char>(s.begin(), s.end(), out); + } + return write<Char>(out, arg); } }; @@ -308,13 +238,12 @@ constexpr size_t parse_text(basic_string_view<Char> str, size_t pos) { } template <typename Args, size_t POS, int ID, typename S> -constexpr auto compile_format_string(S format_str); +constexpr auto compile_format_string(S fmt); template <typename Args, size_t POS, int ID, typename T, typename S> -constexpr auto parse_tail(T head, S format_str) { - if constexpr (POS != - basic_string_view<typename S::char_type>(format_str).size()) { - constexpr auto tail = compile_format_string<Args, POS, ID>(format_str); +constexpr auto parse_tail(T head, S fmt) { + if constexpr (POS != basic_string_view<typename S::char_type>(fmt).size()) { + constexpr auto tail = compile_format_string<Args, POS, ID>(fmt); if constexpr (std::is_same<remove_cvref_t<decltype(tail)>, unknown_format>()) return tail; @@ -385,14 +314,13 @@ struct field_type<T, enable_if_t<detail::is_named_arg<T>::value>> { template <typename T, typename Args, size_t END_POS, int ARG_INDEX, int NEXT_ID, typename S> -constexpr auto parse_replacement_field_then_tail(S format_str) { +constexpr auto parse_replacement_field_then_tail(S fmt) { using char_type = typename S::char_type; - constexpr auto str = basic_string_view<char_type>(format_str); + constexpr auto str = basic_string_view<char_type>(fmt); constexpr char_type c = END_POS != str.size() ? str[END_POS] : char_type(); if constexpr (c == '}') { return parse_tail<Args, END_POS + 1, NEXT_ID>( - field<char_type, typename field_type<T>::type, ARG_INDEX>(), - format_str); + field<char_type, typename field_type<T>::type, ARG_INDEX>(), fmt); } else if constexpr (c != ':') { FMT_THROW(format_error("expected ':'")); } else { @@ -405,7 +333,7 @@ constexpr auto parse_replacement_field_then_tail(S format_str) { return parse_tail<Args, result.end + 1, result.next_arg_id>( spec_field<char_type, typename field_type<T>::type, ARG_INDEX>{ result.fmt}, - format_str); + fmt); } } } @@ -413,22 +341,21 @@ constexpr auto parse_replacement_field_then_tail(S format_str) { // Compiles a non-empty format string and returns the compiled representation // or unknown_format() on unrecognized input. template <typename Args, size_t POS, int ID, typename S> -constexpr auto compile_format_string(S format_str) { +constexpr auto compile_format_string(S fmt) { using char_type = typename S::char_type; - constexpr auto str = basic_string_view<char_type>(format_str); + constexpr auto str = basic_string_view<char_type>(fmt); if constexpr (str[POS] == '{') { if constexpr (POS + 1 == str.size()) FMT_THROW(format_error("unmatched '{' in format string")); if constexpr (str[POS + 1] == '{') { - return parse_tail<Args, POS + 2, ID>(make_text(str, POS, 1), format_str); + return parse_tail<Args, POS + 2, ID>(make_text(str, POS, 1), fmt); } else if constexpr (str[POS + 1] == '}' || str[POS + 1] == ':') { static_assert(ID != manual_indexing_id, "cannot switch from manual to automatic argument indexing"); constexpr auto next_id = ID != manual_indexing_id ? ID + 1 : manual_indexing_id; return parse_replacement_field_then_tail<get_type<ID, Args>, Args, - POS + 1, ID, next_id>( - format_str); + POS + 1, ID, next_id>(fmt); } else { constexpr auto arg_id_result = parse_arg_id<ID>(str.data() + POS + 1, str.data() + str.size()); @@ -444,53 +371,48 @@ constexpr auto compile_format_string(S format_str) { return parse_replacement_field_then_tail<get_type<arg_index, Args>, Args, arg_id_end_pos, arg_index, manual_indexing_id>( - format_str); + fmt); } else if constexpr (arg_id_result.arg_id.kind == arg_id_kind::name) { constexpr auto arg_index = get_arg_index_by_name(arg_id_result.arg_id.val.name, Args{}); - if constexpr (arg_index != invalid_arg_index) { + if constexpr (arg_index >= 0) { constexpr auto next_id = ID != manual_indexing_id ? ID + 1 : manual_indexing_id; return parse_replacement_field_then_tail< decltype(get_type<arg_index, Args>::value), Args, arg_id_end_pos, - arg_index, next_id>(format_str); - } else { - if constexpr (c == '}') { - return parse_tail<Args, arg_id_end_pos + 1, ID>( - runtime_named_field<char_type>{arg_id_result.arg_id.val.name}, - format_str); - } else if constexpr (c == ':') { - return unknown_format(); // no type info for specs parsing - } + arg_index, next_id>(fmt); + } else if constexpr (c == '}') { + return parse_tail<Args, arg_id_end_pos + 1, ID>( + runtime_named_field<char_type>{arg_id_result.arg_id.val.name}, + fmt); + } else if constexpr (c == ':') { + return unknown_format(); // no type info for specs parsing } } } } else if constexpr (str[POS] == '}') { if constexpr (POS + 1 == str.size()) FMT_THROW(format_error("unmatched '}' in format string")); - return parse_tail<Args, POS + 2, ID>(make_text(str, POS, 1), format_str); + return parse_tail<Args, POS + 2, ID>(make_text(str, POS, 1), fmt); } else { constexpr auto end = parse_text(str, POS + 1); if constexpr (end - POS > 1) { - return parse_tail<Args, end, ID>(make_text(str, POS, end - POS), - format_str); + return parse_tail<Args, end, ID>(make_text(str, POS, end - POS), fmt); } else { - return parse_tail<Args, end, ID>(code_unit<char_type>{str[POS]}, - format_str); + return parse_tail<Args, end, ID>(code_unit<char_type>{str[POS]}, fmt); } } } template <typename... Args, typename S, FMT_ENABLE_IF(detail::is_compiled_string<S>::value)> -constexpr auto compile(S format_str) { - constexpr auto str = basic_string_view<typename S::char_type>(format_str); +constexpr auto compile(S fmt) { + constexpr auto str = basic_string_view<typename S::char_type>(fmt); if constexpr (str.size() == 0) { return detail::make_text(str, 0, 0); } else { constexpr auto result = - detail::compile_format_string<detail::type_list<Args...>, 0, 0>( - format_str); + detail::compile_format_string<detail::type_list<Args...>, 0, 0>(fmt); return result; } } @@ -562,33 +484,33 @@ FMT_CONSTEXPR OutputIt format_to(OutputIt out, const S&, Args&&... args) { template <typename OutputIt, typename S, typename... Args, FMT_ENABLE_IF(detail::is_compiled_string<S>::value)> -format_to_n_result<OutputIt> format_to_n(OutputIt out, size_t n, - const S& format_str, Args&&... args) { - auto it = fmt::format_to(detail::truncating_iterator<OutputIt>(out, n), - format_str, std::forward<Args>(args)...); - return {it.base(), it.count()}; +auto format_to_n(OutputIt out, size_t n, const S& fmt, Args&&... args) + -> format_to_n_result<OutputIt> { + using traits = detail::fixed_buffer_traits; + auto buf = detail::iterator_buffer<OutputIt, char, traits>(out, n); + fmt::format_to(std::back_inserter(buf), fmt, std::forward<Args>(args)...); + return {buf.out(), buf.count()}; } template <typename S, typename... Args, FMT_ENABLE_IF(detail::is_compiled_string<S>::value)> -FMT_CONSTEXPR20 size_t formatted_size(const S& format_str, - const Args&... args) { - return fmt::format_to(detail::counting_iterator(), format_str, args...) - .count(); +FMT_CONSTEXPR20 auto formatted_size(const S& fmt, const Args&... args) + -> size_t { + return fmt::format_to(detail::counting_iterator(), fmt, args...).count(); } template <typename S, typename... Args, FMT_ENABLE_IF(detail::is_compiled_string<S>::value)> -void print(std::FILE* f, const S& format_str, const Args&... args) { +void print(std::FILE* f, const S& fmt, const Args&... args) { memory_buffer buffer; - fmt::format_to(std::back_inserter(buffer), format_str, args...); + fmt::format_to(std::back_inserter(buffer), fmt, args...); detail::print(f, {buffer.data(), buffer.size()}); } template <typename S, typename... Args, FMT_ENABLE_IF(detail::is_compiled_string<S>::value)> -void print(const S& format_str, const Args&... args) { - print(stdout, format_str, args...); +void print(const S& fmt, const Args&... args) { + print(stdout, fmt, args...); } #if FMT_USE_NONTYPE_TEMPLATE_ARGS diff --git a/contrib/fmt/include/fmt/core.h b/contrib/fmt/include/fmt/core.h index 46723d598..8ca735f0c 100644 --- a/contrib/fmt/include/fmt/core.h +++ b/contrib/fmt/include/fmt/core.h @@ -1,2951 +1,5 @@ -// Formatting library for C++ - the core API for char/UTF-8 -// -// Copyright (c) 2012 - present, Victor Zverovich -// All rights reserved. -// -// For the license information refer to format.h. +// This file is only provided for compatibility and may be removed in future +// versions. Use fmt/base.h if you don't need fmt::format and fmt/format.h +// otherwise. -#ifndef FMT_CORE_H_ -#define FMT_CORE_H_ - -#include <cstddef> // std::byte -#include <cstdio> // std::FILE -#include <cstring> // std::strlen -#include <iterator> -#include <limits> -#include <string> -#include <type_traits> - -// The fmt library version in the form major * 10000 + minor * 100 + patch. -#define FMT_VERSION 100000 - -#if defined(__clang__) && !defined(__ibmxl__) -# define FMT_CLANG_VERSION (__clang_major__ * 100 + __clang_minor__) -#else -# define FMT_CLANG_VERSION 0 -#endif - -#if defined(__GNUC__) && !defined(__clang__) && !defined(__INTEL_COMPILER) && \ - !defined(__NVCOMPILER) -# define FMT_GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__) -#else -# define FMT_GCC_VERSION 0 -#endif - -#ifndef FMT_GCC_PRAGMA -// Workaround _Pragma bug https://gcc.gnu.org/bugzilla/show_bug.cgi?id=59884. -# if FMT_GCC_VERSION >= 504 -# define FMT_GCC_PRAGMA(arg) _Pragma(arg) -# else -# define FMT_GCC_PRAGMA(arg) -# endif -#endif - -#ifdef __ICL -# define FMT_ICC_VERSION __ICL -#elif defined(__INTEL_COMPILER) -# define FMT_ICC_VERSION __INTEL_COMPILER -#else -# define FMT_ICC_VERSION 0 -#endif - -#ifdef _MSC_VER -# define FMT_MSC_VERSION _MSC_VER -# define FMT_MSC_WARNING(...) __pragma(warning(__VA_ARGS__)) -#else -# define FMT_MSC_VERSION 0 -# define FMT_MSC_WARNING(...) -#endif - -#ifdef _MSVC_LANG -# define FMT_CPLUSPLUS _MSVC_LANG -#else -# define FMT_CPLUSPLUS __cplusplus -#endif - -#ifdef __has_feature -# define FMT_HAS_FEATURE(x) __has_feature(x) -#else -# define FMT_HAS_FEATURE(x) 0 -#endif - -#if defined(__has_include) || FMT_ICC_VERSION >= 1600 || FMT_MSC_VERSION > 1900 -# define FMT_HAS_INCLUDE(x) __has_include(x) -#else -# define FMT_HAS_INCLUDE(x) 0 -#endif - -#ifdef __has_cpp_attribute -# define FMT_HAS_CPP_ATTRIBUTE(x) __has_cpp_attribute(x) -#else -# define FMT_HAS_CPP_ATTRIBUTE(x) 0 -#endif - -#define FMT_HAS_CPP14_ATTRIBUTE(attribute) \ - (FMT_CPLUSPLUS >= 201402L && FMT_HAS_CPP_ATTRIBUTE(attribute)) - -#define FMT_HAS_CPP17_ATTRIBUTE(attribute) \ - (FMT_CPLUSPLUS >= 201703L && FMT_HAS_CPP_ATTRIBUTE(attribute)) - -// Check if relaxed C++14 constexpr is supported. -// GCC doesn't allow throw in constexpr until version 6 (bug 67371). -#ifndef FMT_USE_CONSTEXPR -# if (FMT_HAS_FEATURE(cxx_relaxed_constexpr) || FMT_MSC_VERSION >= 1912 || \ - (FMT_GCC_VERSION >= 600 && FMT_CPLUSPLUS >= 201402L)) && \ - !FMT_ICC_VERSION && !defined(__NVCC__) -# define FMT_USE_CONSTEXPR 1 -# else -# define FMT_USE_CONSTEXPR 0 -# endif -#endif -#if FMT_USE_CONSTEXPR -# define FMT_CONSTEXPR constexpr -#else -# define FMT_CONSTEXPR -#endif - -#if ((FMT_CPLUSPLUS >= 202002L) && \ - (!defined(_GLIBCXX_RELEASE) || _GLIBCXX_RELEASE > 9)) || \ - (FMT_CPLUSPLUS >= 201709L && FMT_GCC_VERSION >= 1002) -# define FMT_CONSTEXPR20 constexpr -#else -# define FMT_CONSTEXPR20 -#endif - -// Check if constexpr std::char_traits<>::{compare,length} are supported. -#if defined(__GLIBCXX__) -# if FMT_CPLUSPLUS >= 201703L && defined(_GLIBCXX_RELEASE) && \ - _GLIBCXX_RELEASE >= 7 // GCC 7+ libstdc++ has _GLIBCXX_RELEASE. -# define FMT_CONSTEXPR_CHAR_TRAITS constexpr -# endif -#elif defined(_LIBCPP_VERSION) && FMT_CPLUSPLUS >= 201703L && \ - _LIBCPP_VERSION >= 4000 -# define FMT_CONSTEXPR_CHAR_TRAITS constexpr -#elif FMT_MSC_VERSION >= 1914 && FMT_CPLUSPLUS >= 201703L -# define FMT_CONSTEXPR_CHAR_TRAITS constexpr -#endif -#ifndef FMT_CONSTEXPR_CHAR_TRAITS -# define FMT_CONSTEXPR_CHAR_TRAITS -#endif - -// Check if exceptions are disabled. -#ifndef FMT_EXCEPTIONS -# if (defined(__GNUC__) && !defined(__EXCEPTIONS)) || \ - (FMT_MSC_VERSION && !_HAS_EXCEPTIONS) -# define FMT_EXCEPTIONS 0 -# else -# define FMT_EXCEPTIONS 1 -# endif -#endif - -// Disable [[noreturn]] on MSVC/NVCC because of bogus unreachable code warnings. -#if FMT_EXCEPTIONS && FMT_HAS_CPP_ATTRIBUTE(noreturn) && !FMT_MSC_VERSION && \ - !defined(__NVCC__) -# define FMT_NORETURN [[noreturn]] -#else -# define FMT_NORETURN -#endif - -#ifndef FMT_NODISCARD -# if FMT_HAS_CPP17_ATTRIBUTE(nodiscard) -# define FMT_NODISCARD [[nodiscard]] -# else -# define FMT_NODISCARD -# endif -#endif - -#ifndef FMT_INLINE -# if FMT_GCC_VERSION || FMT_CLANG_VERSION -# define FMT_INLINE inline __attribute__((always_inline)) -# else -# define FMT_INLINE inline -# endif -#endif - -// An inline std::forward replacement. -#define FMT_FORWARD(...) static_cast<decltype(__VA_ARGS__)&&>(__VA_ARGS__) - -#ifdef _MSC_VER -# define FMT_UNCHECKED_ITERATOR(It) \ - using _Unchecked_type = It // Mark iterator as checked. -#else -# define FMT_UNCHECKED_ITERATOR(It) using unchecked_type = It -#endif - -#ifndef FMT_BEGIN_NAMESPACE -# define FMT_BEGIN_NAMESPACE \ - namespace fmt { \ - inline namespace v10 { -# define FMT_END_NAMESPACE \ - } \ - } -#endif - -#ifndef FMT_MODULE_EXPORT -# define FMT_MODULE_EXPORT -# define FMT_BEGIN_EXPORT -# define FMT_END_EXPORT -#endif - -#if !defined(FMT_HEADER_ONLY) && defined(_WIN32) -# ifdef FMT_LIB_EXPORT -# define FMT_API __declspec(dllexport) -# elif defined(FMT_SHARED) -# define FMT_API __declspec(dllimport) -# endif -#else -# if defined(FMT_LIB_EXPORT) || defined(FMT_SHARED) -# if defined(__GNUC__) || defined(__clang__) -# define FMT_API __attribute__((visibility("default"))) -# endif -# endif -#endif -#ifndef FMT_API -# define FMT_API -#endif - -// libc++ supports string_view in pre-c++17. -#if FMT_HAS_INCLUDE(<string_view>) && \ - (FMT_CPLUSPLUS >= 201703L || defined(_LIBCPP_VERSION)) -# include <string_view> -# define FMT_USE_STRING_VIEW -#elif FMT_HAS_INCLUDE("experimental/string_view") && FMT_CPLUSPLUS >= 201402L -# include <experimental/string_view> -# define FMT_USE_EXPERIMENTAL_STRING_VIEW -#endif - -#ifndef FMT_UNICODE -# define FMT_UNICODE !FMT_MSC_VERSION -#endif - -#ifndef FMT_CONSTEVAL -# if ((FMT_GCC_VERSION >= 1000 || FMT_CLANG_VERSION >= 1101) && \ - (!defined(__apple_build_version__) || \ - __apple_build_version__ >= 14000029L) && \ - FMT_CPLUSPLUS >= 202002L) || \ - (defined(__cpp_consteval) && \ - (!FMT_MSC_VERSION || _MSC_FULL_VER >= 193030704)) -// consteval is broken in MSVC before VS2022 and Apple clang before 14. -# define FMT_CONSTEVAL consteval -# define FMT_HAS_CONSTEVAL -# else -# define FMT_CONSTEVAL -# endif -#endif - -#ifndef FMT_USE_NONTYPE_TEMPLATE_ARGS -# if defined(__cpp_nontype_template_args) && \ - ((FMT_GCC_VERSION >= 903 && FMT_CPLUSPLUS >= 201709L) || \ - __cpp_nontype_template_args >= 201911L) && \ - !defined(__NVCOMPILER) && !defined(__LCC__) -# define FMT_USE_NONTYPE_TEMPLATE_ARGS 1 -# else -# define FMT_USE_NONTYPE_TEMPLATE_ARGS 0 -# endif -#endif - -#if defined __cpp_inline_variables && __cpp_inline_variables >= 201606L -# define FMT_INLINE_VARIABLE inline -#else -# define FMT_INLINE_VARIABLE -#endif - -// Enable minimal optimizations for more compact code in debug mode. -FMT_GCC_PRAGMA("GCC push_options") -#if !defined(__OPTIMIZE__) && !defined(__NVCOMPILER) && !defined(__LCC__) && \ - !defined(__CUDACC__) -FMT_GCC_PRAGMA("GCC optimize(\"Og\")") -#endif - -FMT_BEGIN_NAMESPACE - -// Implementations of enable_if_t and other metafunctions for older systems. -template <bool B, typename T = void> -using enable_if_t = typename std::enable_if<B, T>::type; -template <bool B, typename T, typename F> -using conditional_t = typename std::conditional<B, T, F>::type; -template <bool B> using bool_constant = std::integral_constant<bool, B>; -template <typename T> -using remove_reference_t = typename std::remove_reference<T>::type; -template <typename T> -using remove_const_t = typename std::remove_const<T>::type; -template <typename T> -using remove_cvref_t = typename std::remove_cv<remove_reference_t<T>>::type; -template <typename T> struct type_identity { using type = T; }; -template <typename T> using type_identity_t = typename type_identity<T>::type; -template <typename T> -using underlying_t = typename std::underlying_type<T>::type; - -struct monostate { - constexpr monostate() {} -}; - -// An enable_if helper to be used in template parameters which results in much -// shorter symbols: https://godbolt.org/z/sWw4vP. Extra parentheses are needed -// to workaround a bug in MSVC 2019 (see #1140 and #1186). -#ifdef FMT_DOC -# define FMT_ENABLE_IF(...) -#else -# define FMT_ENABLE_IF(...) fmt::enable_if_t<(__VA_ARGS__), int> = 0 -#endif - -#ifdef __cpp_lib_byte -inline auto format_as(std::byte b) -> unsigned char { - return static_cast<unsigned char>(b); -} -#endif - -namespace detail { -// Suppresses "unused variable" warnings with the method described in -// https://herbsutter.com/2009/10/18/mailbag-shutting-up-compiler-warnings/. -// (void)var does not work on many Intel compilers. -template <typename... T> FMT_CONSTEXPR void ignore_unused(const T&...) {} - -constexpr FMT_INLINE auto is_constant_evaluated( - bool default_value = false) noexcept -> bool { -// Workaround for incompatibility between libstdc++ consteval-based -// std::is_constant_evaluated() implementation and clang-14. -// https://github.com/fmtlib/fmt/issues/3247 -#if FMT_CPLUSPLUS >= 202002L && defined(_GLIBCXX_RELEASE) && \ - _GLIBCXX_RELEASE >= 12 && \ - (FMT_CLANG_VERSION >= 1400 && FMT_CLANG_VERSION < 1500) - ignore_unused(default_value); - return __builtin_is_constant_evaluated(); -#elif defined(__cpp_lib_is_constant_evaluated) - ignore_unused(default_value); - return std::is_constant_evaluated(); -#else - return default_value; -#endif -} - -// Suppresses "conditional expression is constant" warnings. -template <typename T> constexpr FMT_INLINE auto const_check(T value) -> T { - return value; -} - -FMT_NORETURN FMT_API void assert_fail(const char* file, int line, - const char* message); - -#ifndef FMT_ASSERT -# ifdef NDEBUG -// FMT_ASSERT is not empty to avoid -Wempty-body. -# define FMT_ASSERT(condition, message) \ - fmt::detail::ignore_unused((condition), (message)) -# else -# define FMT_ASSERT(condition, message) \ - ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \ - ? (void)0 \ - : fmt::detail::assert_fail(__FILE__, __LINE__, (message))) -# endif -#endif - -#if defined(FMT_USE_STRING_VIEW) -template <typename Char> using std_string_view = std::basic_string_view<Char>; -#elif defined(FMT_USE_EXPERIMENTAL_STRING_VIEW) -template <typename Char> -using std_string_view = std::experimental::basic_string_view<Char>; -#else -template <typename T> struct std_string_view {}; -#endif - -#ifdef FMT_USE_INT128 -// Do nothing. -#elif defined(__SIZEOF_INT128__) && !defined(__NVCC__) && \ - !(FMT_CLANG_VERSION && FMT_MSC_VERSION) -# define FMT_USE_INT128 1 -using int128_opt = __int128_t; // An optional native 128-bit integer. -using uint128_opt = __uint128_t; -template <typename T> inline auto convert_for_visit(T value) -> T { - return value; -} -#else -# define FMT_USE_INT128 0 -#endif -#if !FMT_USE_INT128 -enum class int128_opt {}; -enum class uint128_opt {}; -// Reduce template instantiations. -template <typename T> auto convert_for_visit(T) -> monostate { return {}; } -#endif - -// Casts a nonnegative integer to unsigned. -template <typename Int> -FMT_CONSTEXPR auto to_unsigned(Int value) -> - typename std::make_unsigned<Int>::type { - FMT_ASSERT(std::is_unsigned<Int>::value || value >= 0, "negative value"); - return static_cast<typename std::make_unsigned<Int>::type>(value); -} - -FMT_CONSTEXPR inline auto is_utf8() -> bool { - FMT_MSC_WARNING(suppress : 4566) constexpr unsigned char section[] = "\u00A7"; - - // Avoid buggy sign extensions in MSVC's constant evaluation mode (#2297). - using uchar = unsigned char; - return FMT_UNICODE || (sizeof(section) == 3 && uchar(section[0]) == 0xC2 && - uchar(section[1]) == 0xA7); -} -} // namespace detail - -/** - An implementation of ``std::basic_string_view`` for pre-C++17. It provides a - subset of the API. ``fmt::basic_string_view`` is used for format strings even - if ``std::string_view`` is available to prevent issues when a library is - compiled with a different ``-std`` option than the client code (which is not - recommended). - */ -FMT_MODULE_EXPORT -template <typename Char> class basic_string_view { - private: - const Char* data_; - size_t size_; - - public: - using value_type = Char; - using iterator = const Char*; - - constexpr basic_string_view() noexcept : data_(nullptr), size_(0) {} - - /** Constructs a string reference object from a C string and a size. */ - constexpr basic_string_view(const Char* s, size_t count) noexcept - : data_(s), size_(count) {} - - /** - \rst - Constructs a string reference object from a C string computing - the size with ``std::char_traits<Char>::length``. - \endrst - */ - FMT_CONSTEXPR_CHAR_TRAITS - FMT_INLINE - basic_string_view(const Char* s) - : data_(s), - size_(detail::const_check(std::is_same<Char, char>::value && - !detail::is_constant_evaluated(true)) - ? std::strlen(reinterpret_cast<const char*>(s)) - : std::char_traits<Char>::length(s)) {} - - /** Constructs a string reference from a ``std::basic_string`` object. */ - template <typename Traits, typename Alloc> - FMT_CONSTEXPR basic_string_view( - const std::basic_string<Char, Traits, Alloc>& s) noexcept - : data_(s.data()), size_(s.size()) {} - - template <typename S, FMT_ENABLE_IF(std::is_same< - S, detail::std_string_view<Char>>::value)> - FMT_CONSTEXPR basic_string_view(S s) noexcept - : data_(s.data()), size_(s.size()) {} - - /** Returns a pointer to the string data. */ - constexpr auto data() const noexcept -> const Char* { return data_; } - - /** Returns the string size. */ - constexpr auto size() const noexcept -> size_t { return size_; } - - constexpr auto begin() const noexcept -> iterator { return data_; } - constexpr auto end() const noexcept -> iterator { return data_ + size_; } - - constexpr auto operator[](size_t pos) const noexcept -> const Char& { - return data_[pos]; - } - - FMT_CONSTEXPR void remove_prefix(size_t n) noexcept { - data_ += n; - size_ -= n; - } - - FMT_CONSTEXPR_CHAR_TRAITS bool starts_with( - basic_string_view<Char> sv) const noexcept { - return size_ >= sv.size_ && - std::char_traits<Char>::compare(data_, sv.data_, sv.size_) == 0; - } - FMT_CONSTEXPR_CHAR_TRAITS bool starts_with(Char c) const noexcept { - return size_ >= 1 && std::char_traits<Char>::eq(*data_, c); - } - FMT_CONSTEXPR_CHAR_TRAITS bool starts_with(const Char* s) const { - return starts_with(basic_string_view<Char>(s)); - } - - // Lexicographically compare this string reference to other. - FMT_CONSTEXPR_CHAR_TRAITS auto compare(basic_string_view other) const -> int { - size_t str_size = size_ < other.size_ ? size_ : other.size_; - int result = std::char_traits<Char>::compare(data_, other.data_, str_size); - if (result == 0) - result = size_ == other.size_ ? 0 : (size_ < other.size_ ? -1 : 1); - return result; - } - - FMT_CONSTEXPR_CHAR_TRAITS friend auto operator==(basic_string_view lhs, - basic_string_view rhs) - -> bool { - return lhs.compare(rhs) == 0; - } - friend auto operator!=(basic_string_view lhs, basic_string_view rhs) -> bool { - return lhs.compare(rhs) != 0; - } - friend auto operator<(basic_string_view lhs, basic_string_view rhs) -> bool { - return lhs.compare(rhs) < 0; - } - friend auto operator<=(basic_string_view lhs, basic_string_view rhs) -> bool { - return lhs.compare(rhs) <= 0; - } - friend auto operator>(basic_string_view lhs, basic_string_view rhs) -> bool { - return lhs.compare(rhs) > 0; - } - friend auto operator>=(basic_string_view lhs, basic_string_view rhs) -> bool { - return lhs.compare(rhs) >= 0; - } -}; - -FMT_MODULE_EXPORT -using string_view = basic_string_view<char>; - -/** Specifies if ``T`` is a character type. Can be specialized by users. */ -FMT_MODULE_EXPORT -template <typename T> struct is_char : std::false_type {}; -template <> struct is_char<char> : std::true_type {}; - -namespace detail { - -// A base class for compile-time strings. -struct compile_string {}; - -template <typename S> -struct is_compile_string : std::is_base_of<compile_string, S> {}; - -template <typename Char, FMT_ENABLE_IF(is_char<Char>::value)> -FMT_INLINE auto to_string_view(const Char* s) -> basic_string_view<Char> { - return s; -} -template <typename Char, typename Traits, typename Alloc> -inline auto to_string_view(const std::basic_string<Char, Traits, Alloc>& s) - -> basic_string_view<Char> { - return s; -} -template <typename Char> -constexpr auto to_string_view(basic_string_view<Char> s) - -> basic_string_view<Char> { - return s; -} -template <typename Char, - FMT_ENABLE_IF(!std::is_empty<std_string_view<Char>>::value)> -inline auto to_string_view(std_string_view<Char> s) -> basic_string_view<Char> { - return s; -} -template <typename S, FMT_ENABLE_IF(is_compile_string<S>::value)> -constexpr auto to_string_view(const S& s) - -> basic_string_view<typename S::char_type> { - return basic_string_view<typename S::char_type>(s); -} -void to_string_view(...); - -// Specifies whether S is a string type convertible to fmt::basic_string_view. -// It should be a constexpr function but MSVC 2017 fails to compile it in -// enable_if and MSVC 2015 fails to compile it as an alias template. -// ADL is intentionally disabled as to_string_view is not an extension point. -template <typename S> -struct is_string - : std::is_class<decltype(detail::to_string_view(std::declval<S>()))> {}; - -template <typename S, typename = void> struct char_t_impl {}; -template <typename S> struct char_t_impl<S, enable_if_t<is_string<S>::value>> { - using result = decltype(to_string_view(std::declval<S>())); - using type = typename result::value_type; -}; - -enum class type { - none_type, - // Integer types should go first, - int_type, - uint_type, - long_long_type, - ulong_long_type, - int128_type, - uint128_type, - bool_type, - char_type, - last_integer_type = char_type, - // followed by floating-point types. - float_type, - double_type, - long_double_type, - last_numeric_type = long_double_type, - cstring_type, - string_type, - pointer_type, - custom_type -}; - -// Maps core type T to the corresponding type enum constant. -template <typename T, typename Char> -struct type_constant : std::integral_constant<type, type::custom_type> {}; - -#define FMT_TYPE_CONSTANT(Type, constant) \ - template <typename Char> \ - struct type_constant<Type, Char> \ - : std::integral_constant<type, type::constant> {} - -FMT_TYPE_CONSTANT(int, int_type); -FMT_TYPE_CONSTANT(unsigned, uint_type); -FMT_TYPE_CONSTANT(long long, long_long_type); -FMT_TYPE_CONSTANT(unsigned long long, ulong_long_type); -FMT_TYPE_CONSTANT(int128_opt, int128_type); -FMT_TYPE_CONSTANT(uint128_opt, uint128_type); -FMT_TYPE_CONSTANT(bool, bool_type); -FMT_TYPE_CONSTANT(Char, char_type); -FMT_TYPE_CONSTANT(float, float_type); -FMT_TYPE_CONSTANT(double, double_type); -FMT_TYPE_CONSTANT(long double, long_double_type); -FMT_TYPE_CONSTANT(const Char*, cstring_type); -FMT_TYPE_CONSTANT(basic_string_view<Char>, string_type); -FMT_TYPE_CONSTANT(const void*, pointer_type); - -constexpr bool is_integral_type(type t) { - return t > type::none_type && t <= type::last_integer_type; -} -constexpr bool is_arithmetic_type(type t) { - return t > type::none_type && t <= type::last_numeric_type; -} - -constexpr auto set(type rhs) -> int { return 1 << static_cast<int>(rhs); } -constexpr auto in(type t, int set) -> bool { - return ((set >> static_cast<int>(t)) & 1) != 0; -} - -// Bitsets of types. -enum { - sint_set = - set(type::int_type) | set(type::long_long_type) | set(type::int128_type), - uint_set = set(type::uint_type) | set(type::ulong_long_type) | - set(type::uint128_type), - bool_set = set(type::bool_type), - char_set = set(type::char_type), - float_set = set(type::float_type) | set(type::double_type) | - set(type::long_double_type), - string_set = set(type::string_type), - cstring_set = set(type::cstring_type), - pointer_set = set(type::pointer_type) -}; - -FMT_NORETURN FMT_API void throw_format_error(const char* message); - -struct error_handler { - constexpr error_handler() = default; - - // This function is intentionally not constexpr to give a compile-time error. - FMT_NORETURN void on_error(const char* message) { - throw_format_error(message); - } -}; -} // namespace detail - -/** String's character type. */ -template <typename S> using char_t = typename detail::char_t_impl<S>::type; - -/** - \rst - Parsing context consisting of a format string range being parsed and an - argument counter for automatic indexing. - You can use the ``format_parse_context`` type alias for ``char`` instead. - \endrst - */ -FMT_MODULE_EXPORT -template <typename Char> class basic_format_parse_context { - private: - basic_string_view<Char> format_str_; - int next_arg_id_; - - FMT_CONSTEXPR void do_check_arg_id(int id); - - public: - using char_type = Char; - using iterator = const Char*; - - explicit constexpr basic_format_parse_context( - basic_string_view<Char> format_str, int next_arg_id = 0) - : format_str_(format_str), next_arg_id_(next_arg_id) {} - - /** - Returns an iterator to the beginning of the format string range being - parsed. - */ - constexpr auto begin() const noexcept -> iterator { - return format_str_.begin(); - } - - /** - Returns an iterator past the end of the format string range being parsed. - */ - constexpr auto end() const noexcept -> iterator { return format_str_.end(); } - - /** Advances the begin iterator to ``it``. */ - FMT_CONSTEXPR void advance_to(iterator it) { - format_str_.remove_prefix(detail::to_unsigned(it - begin())); - } - - /** - Reports an error if using the manual argument indexing; otherwise returns - the next argument index and switches to the automatic indexing. - */ - FMT_CONSTEXPR auto next_arg_id() -> int { - if (next_arg_id_ < 0) { - detail::throw_format_error( - "cannot switch from manual to automatic argument indexing"); - return 0; - } - int id = next_arg_id_++; - do_check_arg_id(id); - return id; - } - - /** - Reports an error if using the automatic argument indexing; otherwise - switches to the manual indexing. - */ - FMT_CONSTEXPR void check_arg_id(int id) { - if (next_arg_id_ > 0) { - detail::throw_format_error( - "cannot switch from automatic to manual argument indexing"); - return; - } - next_arg_id_ = -1; - do_check_arg_id(id); - } - FMT_CONSTEXPR void check_arg_id(basic_string_view<Char>) {} - FMT_CONSTEXPR void check_dynamic_spec(int arg_id); -}; - -FMT_MODULE_EXPORT -using format_parse_context = basic_format_parse_context<char>; - -namespace detail { -// A parse context with extra data used only in compile-time checks. -template <typename Char> -class compile_parse_context : public basic_format_parse_context<Char> { - private: - int num_args_; - const type* types_; - using base = basic_format_parse_context<Char>; - - public: - explicit FMT_CONSTEXPR compile_parse_context( - basic_string_view<Char> format_str, int num_args, const type* types, - int next_arg_id = 0) - : base(format_str, next_arg_id), num_args_(num_args), types_(types) {} - - constexpr auto num_args() const -> int { return num_args_; } - constexpr auto arg_type(int id) const -> type { return types_[id]; } - - FMT_CONSTEXPR auto next_arg_id() -> int { - int id = base::next_arg_id(); - if (id >= num_args_) throw_format_error("argument not found"); - return id; - } - - FMT_CONSTEXPR void check_arg_id(int id) { - base::check_arg_id(id); - if (id >= num_args_) throw_format_error("argument not found"); - } - using base::check_arg_id; - - FMT_CONSTEXPR void check_dynamic_spec(int arg_id) { - detail::ignore_unused(arg_id); -#if !defined(__LCC__) - if (arg_id < num_args_ && types_ && !is_integral_type(types_[arg_id])) - throw_format_error("width/precision is not integer"); -#endif - } -}; -} // namespace detail - -template <typename Char> -FMT_CONSTEXPR void basic_format_parse_context<Char>::do_check_arg_id(int id) { - // Argument id is only checked at compile-time during parsing because - // formatting has its own validation. - if (detail::is_constant_evaluated() && - (!FMT_GCC_VERSION || FMT_GCC_VERSION >= 1200)) { - using context = detail::compile_parse_context<Char>; - if (id >= static_cast<context*>(this)->num_args()) - detail::throw_format_error("argument not found"); - } -} - -template <typename Char> -FMT_CONSTEXPR void basic_format_parse_context<Char>::check_dynamic_spec( - int arg_id) { - if (detail::is_constant_evaluated() && - (!FMT_GCC_VERSION || FMT_GCC_VERSION >= 1200)) { - using context = detail::compile_parse_context<Char>; - static_cast<context*>(this)->check_dynamic_spec(arg_id); - } -} - -FMT_MODULE_EXPORT template <typename Context> class basic_format_arg; -FMT_MODULE_EXPORT template <typename Context> class basic_format_args; -FMT_MODULE_EXPORT template <typename Context> class dynamic_format_arg_store; - -// A formatter for objects of type T. -FMT_MODULE_EXPORT -template <typename T, typename Char = char, typename Enable = void> -struct formatter { - // A deleted default constructor indicates a disabled formatter. - formatter() = delete; -}; - -// Specifies if T has an enabled formatter specialization. A type can be -// formattable even if it doesn't have a formatter e.g. via a conversion. -template <typename T, typename Context> -using has_formatter = - std::is_constructible<typename Context::template formatter_type<T>>; - -// Checks whether T is a container with contiguous storage. -template <typename T> struct is_contiguous : std::false_type {}; -template <typename Char> -struct is_contiguous<std::basic_string<Char>> : std::true_type {}; - -class appender; - -namespace detail { - -template <typename Context, typename T> -constexpr auto has_const_formatter_impl(T*) - -> decltype(typename Context::template formatter_type<T>().format( - std::declval<const T&>(), std::declval<Context&>()), - true) { - return true; -} -template <typename Context> -constexpr auto has_const_formatter_impl(...) -> bool { - return false; -} -template <typename T, typename Context> -constexpr auto has_const_formatter() -> bool { - return has_const_formatter_impl<Context>(static_cast<T*>(nullptr)); -} - -// Extracts a reference to the container from back_insert_iterator. -template <typename Container> -inline auto get_container(std::back_insert_iterator<Container> it) - -> Container& { - using base = std::back_insert_iterator<Container>; - struct accessor : base { - accessor(base b) : base(b) {} - using base::container; - }; - return *accessor(it).container; -} - -template <typename Char, typename InputIt, typename OutputIt> -FMT_CONSTEXPR auto copy_str(InputIt begin, InputIt end, OutputIt out) - -> OutputIt { - while (begin != end) *out++ = static_cast<Char>(*begin++); - return out; -} - -template <typename Char, typename T, typename U, - FMT_ENABLE_IF( - std::is_same<remove_const_t<T>, U>::value&& is_char<U>::value)> -FMT_CONSTEXPR auto copy_str(T* begin, T* end, U* out) -> U* { - if (is_constant_evaluated()) return copy_str<Char, T*, U*>(begin, end, out); - auto size = to_unsigned(end - begin); - if (size > 0) memcpy(out, begin, size * sizeof(U)); - return out + size; -} - -/** - \rst - A contiguous memory buffer with an optional growing ability. It is an internal - class and shouldn't be used directly, only via `~fmt::basic_memory_buffer`. - \endrst - */ -template <typename T> class buffer { - private: - T* ptr_; - size_t size_; - size_t capacity_; - - protected: - // Don't initialize ptr_ since it is not accessed to save a few cycles. - FMT_MSC_WARNING(suppress : 26495) - buffer(size_t sz) noexcept : size_(sz), capacity_(sz) {} - - FMT_CONSTEXPR20 buffer(T* p = nullptr, size_t sz = 0, size_t cap = 0) noexcept - : ptr_(p), size_(sz), capacity_(cap) {} - - FMT_CONSTEXPR20 ~buffer() = default; - buffer(buffer&&) = default; - - /** Sets the buffer data and capacity. */ - FMT_CONSTEXPR void set(T* buf_data, size_t buf_capacity) noexcept { - ptr_ = buf_data; - capacity_ = buf_capacity; - } - - /** Increases the buffer capacity to hold at least *capacity* elements. */ - virtual FMT_CONSTEXPR20 void grow(size_t capacity) = 0; - - public: - using value_type = T; - using const_reference = const T&; - - buffer(const buffer&) = delete; - void operator=(const buffer&) = delete; - - FMT_INLINE auto begin() noexcept -> T* { return ptr_; } - FMT_INLINE auto end() noexcept -> T* { return ptr_ + size_; } - - FMT_INLINE auto begin() const noexcept -> const T* { return ptr_; } - FMT_INLINE auto end() const noexcept -> const T* { return ptr_ + size_; } - - /** Returns the size of this buffer. */ - constexpr auto size() const noexcept -> size_t { return size_; } - - /** Returns the capacity of this buffer. */ - constexpr auto capacity() const noexcept -> size_t { return capacity_; } - - /** Returns a pointer to the buffer data. */ - FMT_CONSTEXPR auto data() noexcept -> T* { return ptr_; } - - /** Returns a pointer to the buffer data. */ - FMT_CONSTEXPR auto data() const noexcept -> const T* { return ptr_; } - - /** Clears this buffer. */ - void clear() { size_ = 0; } - - // Tries resizing the buffer to contain *count* elements. If T is a POD type - // the new elements may not be initialized. - FMT_CONSTEXPR20 void try_resize(size_t count) { - try_reserve(count); - size_ = count <= capacity_ ? count : capacity_; - } - - // Tries increasing the buffer capacity to *new_capacity*. It can increase the - // capacity by a smaller amount than requested but guarantees there is space - // for at least one additional element either by increasing the capacity or by - // flushing the buffer if it is full. - FMT_CONSTEXPR20 void try_reserve(size_t new_capacity) { - if (new_capacity > capacity_) grow(new_capacity); - } - - FMT_CONSTEXPR20 void push_back(const T& value) { - try_reserve(size_ + 1); - ptr_[size_++] = value; - } - - /** Appends data to the end of the buffer. */ - template <typename U> void append(const U* begin, const U* end); - - template <typename Idx> FMT_CONSTEXPR auto operator[](Idx index) -> T& { - return ptr_[index]; - } - template <typename Idx> - FMT_CONSTEXPR auto operator[](Idx index) const -> const T& { - return ptr_[index]; - } -}; - -struct buffer_traits { - explicit buffer_traits(size_t) {} - auto count() const -> size_t { return 0; } - auto limit(size_t size) -> size_t { return size; } -}; - -class fixed_buffer_traits { - private: - size_t count_ = 0; - size_t limit_; - - public: - explicit fixed_buffer_traits(size_t limit) : limit_(limit) {} - auto count() const -> size_t { return count_; } - auto limit(size_t size) -> size_t { - size_t n = limit_ > count_ ? limit_ - count_ : 0; - count_ += size; - return size < n ? size : n; - } -}; - -// A buffer that writes to an output iterator when flushed. -template <typename OutputIt, typename T, typename Traits = buffer_traits> -class iterator_buffer final : public Traits, public buffer<T> { - private: - OutputIt out_; - enum { buffer_size = 256 }; - T data_[buffer_size]; - - protected: - FMT_CONSTEXPR20 void grow(size_t) override { - if (this->size() == buffer_size) flush(); - } - - void flush() { - auto size = this->size(); - this->clear(); - out_ = copy_str<T>(data_, data_ + this->limit(size), out_); - } - - public: - explicit iterator_buffer(OutputIt out, size_t n = buffer_size) - : Traits(n), buffer<T>(data_, 0, buffer_size), out_(out) {} - iterator_buffer(iterator_buffer&& other) - : Traits(other), buffer<T>(data_, 0, buffer_size), out_(other.out_) {} - ~iterator_buffer() { flush(); } - - auto out() -> OutputIt { - flush(); - return out_; - } - auto count() const -> size_t { return Traits::count() + this->size(); } -}; - -template <typename T> -class iterator_buffer<T*, T, fixed_buffer_traits> final - : public fixed_buffer_traits, - public buffer<T> { - private: - T* out_; - enum { buffer_size = 256 }; - T data_[buffer_size]; - - protected: - FMT_CONSTEXPR20 void grow(size_t) override { - if (this->size() == this->capacity()) flush(); - } - - void flush() { - size_t n = this->limit(this->size()); - if (this->data() == out_) { - out_ += n; - this->set(data_, buffer_size); - } - this->clear(); - } - - public: - explicit iterator_buffer(T* out, size_t n = buffer_size) - : fixed_buffer_traits(n), buffer<T>(out, 0, n), out_(out) {} - iterator_buffer(iterator_buffer&& other) - : fixed_buffer_traits(other), - buffer<T>(std::move(other)), - out_(other.out_) { - if (this->data() != out_) { - this->set(data_, buffer_size); - this->clear(); - } - } - ~iterator_buffer() { flush(); } - - auto out() -> T* { - flush(); - return out_; - } - auto count() const -> size_t { - return fixed_buffer_traits::count() + this->size(); - } -}; - -template <typename T> class iterator_buffer<T*, T> final : public buffer<T> { - protected: - FMT_CONSTEXPR20 void grow(size_t) override {} - - public: - explicit iterator_buffer(T* out, size_t = 0) : buffer<T>(out, 0, ~size_t()) {} - - auto out() -> T* { return &*this->end(); } -}; - -// A buffer that writes to a container with the contiguous storage. -template <typename Container> -class iterator_buffer<std::back_insert_iterator<Container>, - enable_if_t<is_contiguous<Container>::value, - typename Container::value_type>> - final : public buffer<typename Container::value_type> { - private: - Container& container_; - - protected: - FMT_CONSTEXPR20 void grow(size_t capacity) override { - container_.resize(capacity); - this->set(&container_[0], capacity); - } - - public: - explicit iterator_buffer(Container& c) - : buffer<typename Container::value_type>(c.size()), container_(c) {} - explicit iterator_buffer(std::back_insert_iterator<Container> out, size_t = 0) - : iterator_buffer(get_container(out)) {} - - auto out() -> std::back_insert_iterator<Container> { - return std::back_inserter(container_); - } -}; - -// A buffer that counts the number of code units written discarding the output. -template <typename T = char> class counting_buffer final : public buffer<T> { - private: - enum { buffer_size = 256 }; - T data_[buffer_size]; - size_t count_ = 0; - - protected: - FMT_CONSTEXPR20 void grow(size_t) override { - if (this->size() != buffer_size) return; - count_ += this->size(); - this->clear(); - } - - public: - counting_buffer() : buffer<T>(data_, 0, buffer_size) {} - - auto count() -> size_t { return count_ + this->size(); } -}; - -template <typename T> -using buffer_appender = conditional_t<std::is_same<T, char>::value, appender, - std::back_insert_iterator<buffer<T>>>; - -// Maps an output iterator to a buffer. -template <typename T, typename OutputIt> -auto get_buffer(OutputIt out) -> iterator_buffer<OutputIt, T> { - return iterator_buffer<OutputIt, T>(out); -} -template <typename T, typename Buf, - FMT_ENABLE_IF(std::is_base_of<buffer<char>, Buf>::value)> -auto get_buffer(std::back_insert_iterator<Buf> out) -> buffer<char>& { - return get_container(out); -} - -template <typename Buf, typename OutputIt> -FMT_INLINE auto get_iterator(Buf& buf, OutputIt) -> decltype(buf.out()) { - return buf.out(); -} -template <typename T, typename OutputIt> -auto get_iterator(buffer<T>&, OutputIt out) -> OutputIt { - return out; -} - -struct view {}; - -template <typename Char, typename T> struct named_arg : view { - const Char* name; - const T& value; - named_arg(const Char* n, const T& v) : name(n), value(v) {} -}; - -template <typename Char> struct named_arg_info { - const Char* name; - int id; -}; - -template <typename T, typename Char, size_t NUM_ARGS, size_t NUM_NAMED_ARGS> -struct arg_data { - // args_[0].named_args points to named_args_ to avoid bloating format_args. - // +1 to workaround a bug in gcc 7.5 that causes duplicated-branches warning. - T args_[1 + (NUM_ARGS != 0 ? NUM_ARGS : +1)]; - named_arg_info<Char> named_args_[NUM_NAMED_ARGS]; - - template <typename... U> - arg_data(const U&... init) : args_{T(named_args_, NUM_NAMED_ARGS), init...} {} - arg_data(const arg_data& other) = delete; - auto args() const -> const T* { return args_ + 1; } - auto named_args() -> named_arg_info<Char>* { return named_args_; } -}; - -template <typename T, typename Char, size_t NUM_ARGS> -struct arg_data<T, Char, NUM_ARGS, 0> { - // +1 to workaround a bug in gcc 7.5 that causes duplicated-branches warning. - T args_[NUM_ARGS != 0 ? NUM_ARGS : +1]; - - template <typename... U> - FMT_CONSTEXPR FMT_INLINE arg_data(const U&... init) : args_{init...} {} - FMT_CONSTEXPR FMT_INLINE auto args() const -> const T* { return args_; } - FMT_CONSTEXPR FMT_INLINE auto named_args() -> std::nullptr_t { - return nullptr; - } -}; - -template <typename Char> -inline void init_named_args(named_arg_info<Char>*, int, int) {} - -template <typename T> struct is_named_arg : std::false_type {}; -template <typename T> struct is_statically_named_arg : std::false_type {}; - -template <typename T, typename Char> -struct is_named_arg<named_arg<Char, T>> : std::true_type {}; - -template <typename Char, typename T, typename... Tail, - FMT_ENABLE_IF(!is_named_arg<T>::value)> -void init_named_args(named_arg_info<Char>* named_args, int arg_count, - int named_arg_count, const T&, const Tail&... args) { - init_named_args(named_args, arg_count + 1, named_arg_count, args...); -} - -template <typename Char, typename T, typename... Tail, - FMT_ENABLE_IF(is_named_arg<T>::value)> -void init_named_args(named_arg_info<Char>* named_args, int arg_count, - int named_arg_count, const T& arg, const Tail&... args) { - named_args[named_arg_count++] = {arg.name, arg_count}; - init_named_args(named_args, arg_count + 1, named_arg_count, args...); -} - -template <typename... Args> -FMT_CONSTEXPR FMT_INLINE void init_named_args(std::nullptr_t, int, int, - const Args&...) {} - -template <bool B = false> constexpr auto count() -> size_t { return B ? 1 : 0; } -template <bool B1, bool B2, bool... Tail> constexpr auto count() -> size_t { - return (B1 ? 1 : 0) + count<B2, Tail...>(); -} - -template <typename... Args> constexpr auto count_named_args() -> size_t { - return count<is_named_arg<Args>::value...>(); -} - -template <typename... Args> -constexpr auto count_statically_named_args() -> size_t { - return count<is_statically_named_arg<Args>::value...>(); -} - -struct unformattable {}; -struct unformattable_char : unformattable {}; -struct unformattable_pointer : unformattable {}; - -template <typename Char> struct string_value { - const Char* data; - size_t size; -}; - -template <typename Char> struct named_arg_value { - const named_arg_info<Char>* data; - size_t size; -}; - -template <typename Context> struct custom_value { - using parse_context = typename Context::parse_context_type; - void* value; - void (*format)(void* arg, parse_context& parse_ctx, Context& ctx); -}; - -// A formatting argument value. -template <typename Context> class value { - public: - using char_type = typename Context::char_type; - - union { - monostate no_value; - int int_value; - unsigned uint_value; - long long long_long_value; - unsigned long long ulong_long_value; - int128_opt int128_value; - uint128_opt uint128_value; - bool bool_value; - char_type char_value; - float float_value; - double double_value; - long double long_double_value; - const void* pointer; - string_value<char_type> string; - custom_value<Context> custom; - named_arg_value<char_type> named_args; - }; - - constexpr FMT_INLINE value() : no_value() {} - constexpr FMT_INLINE value(int val) : int_value(val) {} - constexpr FMT_INLINE value(unsigned val) : uint_value(val) {} - constexpr FMT_INLINE value(long long val) : long_long_value(val) {} - constexpr FMT_INLINE value(unsigned long long val) : ulong_long_value(val) {} - FMT_INLINE value(int128_opt val) : int128_value(val) {} - FMT_INLINE value(uint128_opt val) : uint128_value(val) {} - constexpr FMT_INLINE value(float val) : float_value(val) {} - constexpr FMT_INLINE value(double val) : double_value(val) {} - FMT_INLINE value(long double val) : long_double_value(val) {} - constexpr FMT_INLINE value(bool val) : bool_value(val) {} - constexpr FMT_INLINE value(char_type val) : char_value(val) {} - FMT_CONSTEXPR FMT_INLINE value(const char_type* val) { - string.data = val; - if (is_constant_evaluated()) string.size = {}; - } - FMT_CONSTEXPR FMT_INLINE value(basic_string_view<char_type> val) { - string.data = val.data(); - string.size = val.size(); - } - FMT_INLINE value(const void* val) : pointer(val) {} - FMT_INLINE value(const named_arg_info<char_type>* args, size_t size) - : named_args{args, size} {} - - template <typename T> FMT_CONSTEXPR FMT_INLINE value(T& val) { - using value_type = remove_cvref_t<T>; - custom.value = const_cast<value_type*>(&val); - // Get the formatter type through the context to allow different contexts - // have different extension points, e.g. `formatter<T>` for `format` and - // `printf_formatter<T>` for `printf`. - custom.format = format_custom_arg< - value_type, typename Context::template formatter_type<value_type>>; - } - value(unformattable); - value(unformattable_char); - value(unformattable_pointer); - - private: - // Formats an argument of a custom type, such as a user-defined class. - template <typename T, typename Formatter> - static void format_custom_arg(void* arg, - typename Context::parse_context_type& parse_ctx, - Context& ctx) { - auto f = Formatter(); - parse_ctx.advance_to(f.parse(parse_ctx)); - using qualified_type = - conditional_t<has_const_formatter<T, Context>(), const T, T>; - ctx.advance_to(f.format(*static_cast<qualified_type*>(arg), ctx)); - } -}; - -template <typename Context, typename T> -FMT_CONSTEXPR auto make_arg(T&& value) -> basic_format_arg<Context>; - -// To minimize the number of types we need to deal with, long is translated -// either to int or to long long depending on its size. -enum { long_short = sizeof(long) == sizeof(int) }; -using long_type = conditional_t<long_short, int, long long>; -using ulong_type = conditional_t<long_short, unsigned, unsigned long long>; - -template <typename T> struct format_as_result { - template <typename U, - FMT_ENABLE_IF(std::is_enum<U>::value || std::is_class<U>::value)> - static auto map(U*) -> decltype(format_as(std::declval<U>())); - static auto map(...) -> void; - - using type = decltype(map(static_cast<T*>(nullptr))); -}; -template <typename T> using format_as_t = typename format_as_result<T>::type; - -template <typename T> -struct has_format_as - : bool_constant<!std::is_same<format_as_t<T>, void>::value> {}; - -// Maps formatting arguments to core types. -// arg_mapper reports errors by returning unformattable instead of using -// static_assert because it's used in the is_formattable trait. -template <typename Context> struct arg_mapper { - using char_type = typename Context::char_type; - - FMT_CONSTEXPR FMT_INLINE auto map(signed char val) -> int { return val; } - FMT_CONSTEXPR FMT_INLINE auto map(unsigned char val) -> unsigned { - return val; - } - FMT_CONSTEXPR FMT_INLINE auto map(short val) -> int { return val; } - FMT_CONSTEXPR FMT_INLINE auto map(unsigned short val) -> unsigned { - return val; - } - FMT_CONSTEXPR FMT_INLINE auto map(int val) -> int { return val; } - FMT_CONSTEXPR FMT_INLINE auto map(unsigned val) -> unsigned { return val; } - FMT_CONSTEXPR FMT_INLINE auto map(long val) -> long_type { return val; } - FMT_CONSTEXPR FMT_INLINE auto map(unsigned long val) -> ulong_type { - return val; - } - FMT_CONSTEXPR FMT_INLINE auto map(long long val) -> long long { return val; } - FMT_CONSTEXPR FMT_INLINE auto map(unsigned long long val) - -> unsigned long long { - return val; - } - FMT_CONSTEXPR FMT_INLINE auto map(int128_opt val) -> int128_opt { - return val; - } - FMT_CONSTEXPR FMT_INLINE auto map(uint128_opt val) -> uint128_opt { - return val; - } - FMT_CONSTEXPR FMT_INLINE auto map(bool val) -> bool { return val; } - - template <typename T, FMT_ENABLE_IF(std::is_same<T, char>::value || - std::is_same<T, char_type>::value)> - FMT_CONSTEXPR FMT_INLINE auto map(T val) -> char_type { - return val; - } - template <typename T, enable_if_t<(std::is_same<T, wchar_t>::value || -#ifdef __cpp_char8_t - std::is_same<T, char8_t>::value || -#endif - std::is_same<T, char16_t>::value || - std::is_same<T, char32_t>::value) && - !std::is_same<T, char_type>::value, - int> = 0> - FMT_CONSTEXPR FMT_INLINE auto map(T) -> unformattable_char { - return {}; - } - - FMT_CONSTEXPR FMT_INLINE auto map(float val) -> float { return val; } - FMT_CONSTEXPR FMT_INLINE auto map(double val) -> double { return val; } - FMT_CONSTEXPR FMT_INLINE auto map(long double val) -> long double { - return val; - } - - FMT_CONSTEXPR FMT_INLINE auto map(char_type* val) -> const char_type* { - return val; - } - FMT_CONSTEXPR FMT_INLINE auto map(const char_type* val) -> const char_type* { - return val; - } - template <typename T, - FMT_ENABLE_IF(is_string<T>::value && !std::is_pointer<T>::value && - std::is_same<char_type, char_t<T>>::value)> - FMT_CONSTEXPR FMT_INLINE auto map(const T& val) - -> basic_string_view<char_type> { - return to_string_view(val); - } - template <typename T, - FMT_ENABLE_IF(is_string<T>::value && !std::is_pointer<T>::value && - !std::is_same<char_type, char_t<T>>::value)> - FMT_CONSTEXPR FMT_INLINE auto map(const T&) -> unformattable_char { - return {}; - } - - FMT_CONSTEXPR FMT_INLINE auto map(void* val) -> const void* { return val; } - FMT_CONSTEXPR FMT_INLINE auto map(const void* val) -> const void* { - return val; - } - FMT_CONSTEXPR FMT_INLINE auto map(std::nullptr_t val) -> const void* { - return val; - } - - // Use SFINAE instead of a const T* parameter to avoid a conflict with the - // array overload. - template < - typename T, - FMT_ENABLE_IF( - std::is_pointer<T>::value || std::is_member_pointer<T>::value || - std::is_function<typename std::remove_pointer<T>::type>::value || - (std::is_convertible<const T&, const void*>::value && - !std::is_convertible<const T&, const char_type*>::value && - !has_formatter<T, Context>::value))> - FMT_CONSTEXPR auto map(const T&) -> unformattable_pointer { - return {}; - } - - template <typename T, std::size_t N, - FMT_ENABLE_IF(!std::is_same<T, wchar_t>::value)> - FMT_CONSTEXPR FMT_INLINE auto map(const T (&values)[N]) -> const T (&)[N] { - return values; - } - - // Only map owning types because mapping views can be unsafe. - template <typename T, typename U = format_as_t<T>, - FMT_ENABLE_IF(std::is_arithmetic<U>::value)> - FMT_CONSTEXPR FMT_INLINE auto map(const T& val) -> decltype(this->map(U())) { - return map(format_as(val)); - } - - template <typename T, typename U = remove_cvref_t<T>> - struct formattable - : bool_constant<has_const_formatter<U, Context>() || - (has_formatter<U, Context>::value && - !std::is_const<remove_reference_t<T>>::value)> {}; - - template <typename T, FMT_ENABLE_IF(formattable<T>::value)> - FMT_CONSTEXPR FMT_INLINE auto do_map(T&& val) -> T& { - return val; - } - template <typename T, FMT_ENABLE_IF(!formattable<T>::value)> - FMT_CONSTEXPR FMT_INLINE auto do_map(T&&) -> unformattable { - return {}; - } - - template <typename T, typename U = remove_cvref_t<T>, - FMT_ENABLE_IF((std::is_class<U>::value || std::is_enum<U>::value || - std::is_union<U>::value) && - !is_string<U>::value && !is_char<U>::value && - !is_named_arg<U>::value && - !std::is_arithmetic<format_as_t<U>>::value)> - FMT_CONSTEXPR FMT_INLINE auto map(T&& val) - -> decltype(this->do_map(std::forward<T>(val))) { - return do_map(std::forward<T>(val)); - } - - template <typename T, FMT_ENABLE_IF(is_named_arg<T>::value)> - FMT_CONSTEXPR FMT_INLINE auto map(const T& named_arg) - -> decltype(this->map(named_arg.value)) { - return map(named_arg.value); - } - - auto map(...) -> unformattable { return {}; } -}; - -// A type constant after applying arg_mapper<Context>. -template <typename T, typename Context> -using mapped_type_constant = - type_constant<decltype(arg_mapper<Context>().map(std::declval<const T&>())), - typename Context::char_type>; - -enum { packed_arg_bits = 4 }; -// Maximum number of arguments with packed types. -enum { max_packed_args = 62 / packed_arg_bits }; -enum : unsigned long long { is_unpacked_bit = 1ULL << 63 }; -enum : unsigned long long { has_named_args_bit = 1ULL << 62 }; -} // namespace detail - -// An output iterator that appends to a buffer. -// It is used to reduce symbol sizes for the common case. -class appender : public std::back_insert_iterator<detail::buffer<char>> { - using base = std::back_insert_iterator<detail::buffer<char>>; - - public: - using std::back_insert_iterator<detail::buffer<char>>::back_insert_iterator; - appender(base it) noexcept : base(it) {} - FMT_UNCHECKED_ITERATOR(appender); - - auto operator++() noexcept -> appender& { return *this; } - auto operator++(int) noexcept -> appender { return *this; } -}; - -// A formatting argument. It is a trivially copyable/constructible type to -// allow storage in basic_memory_buffer. -template <typename Context> class basic_format_arg { - private: - detail::value<Context> value_; - detail::type type_; - - template <typename ContextType, typename T> - friend FMT_CONSTEXPR auto detail::make_arg(T&& value) - -> basic_format_arg<ContextType>; - - template <typename Visitor, typename Ctx> - friend FMT_CONSTEXPR auto visit_format_arg(Visitor&& vis, - const basic_format_arg<Ctx>& arg) - -> decltype(vis(0)); - - friend class basic_format_args<Context>; - friend class dynamic_format_arg_store<Context>; - - using char_type = typename Context::char_type; - - template <typename T, typename Char, size_t NUM_ARGS, size_t NUM_NAMED_ARGS> - friend struct detail::arg_data; - - basic_format_arg(const detail::named_arg_info<char_type>* args, size_t size) - : value_(args, size) {} - - public: - class handle { - public: - explicit handle(detail::custom_value<Context> custom) : custom_(custom) {} - - void format(typename Context::parse_context_type& parse_ctx, - Context& ctx) const { - custom_.format(custom_.value, parse_ctx, ctx); - } - - private: - detail::custom_value<Context> custom_; - }; - - constexpr basic_format_arg() : type_(detail::type::none_type) {} - - constexpr explicit operator bool() const noexcept { - return type_ != detail::type::none_type; - } - - auto type() const -> detail::type { return type_; } - - auto is_integral() const -> bool { return detail::is_integral_type(type_); } - auto is_arithmetic() const -> bool { - return detail::is_arithmetic_type(type_); - } -}; - -/** - \rst - Visits an argument dispatching to the appropriate visit method based on - the argument type. For example, if the argument type is ``double`` then - ``vis(value)`` will be called with the value of type ``double``. - \endrst - */ -FMT_MODULE_EXPORT -template <typename Visitor, typename Context> -FMT_CONSTEXPR FMT_INLINE auto visit_format_arg( - Visitor&& vis, const basic_format_arg<Context>& arg) -> decltype(vis(0)) { - switch (arg.type_) { - case detail::type::none_type: - break; - case detail::type::int_type: - return vis(arg.value_.int_value); - case detail::type::uint_type: - return vis(arg.value_.uint_value); - case detail::type::long_long_type: - return vis(arg.value_.long_long_value); - case detail::type::ulong_long_type: - return vis(arg.value_.ulong_long_value); - case detail::type::int128_type: - return vis(detail::convert_for_visit(arg.value_.int128_value)); - case detail::type::uint128_type: - return vis(detail::convert_for_visit(arg.value_.uint128_value)); - case detail::type::bool_type: - return vis(arg.value_.bool_value); - case detail::type::char_type: - return vis(arg.value_.char_value); - case detail::type::float_type: - return vis(arg.value_.float_value); - case detail::type::double_type: - return vis(arg.value_.double_value); - case detail::type::long_double_type: - return vis(arg.value_.long_double_value); - case detail::type::cstring_type: - return vis(arg.value_.string.data); - case detail::type::string_type: - using sv = basic_string_view<typename Context::char_type>; - return vis(sv(arg.value_.string.data, arg.value_.string.size)); - case detail::type::pointer_type: - return vis(arg.value_.pointer); - case detail::type::custom_type: - return vis(typename basic_format_arg<Context>::handle(arg.value_.custom)); - } - return vis(monostate()); -} - -namespace detail { - -template <typename Char, typename InputIt> -auto copy_str(InputIt begin, InputIt end, appender out) -> appender { - get_container(out).append(begin, end); - return out; -} - -template <typename Char, typename R, typename OutputIt> -FMT_CONSTEXPR auto copy_str(R&& rng, OutputIt out) -> OutputIt { - return detail::copy_str<Char>(rng.begin(), rng.end(), out); -} - -#if FMT_GCC_VERSION && FMT_GCC_VERSION < 500 -// A workaround for gcc 4.8 to make void_t work in a SFINAE context. -template <typename...> struct void_t_impl { using type = void; }; -template <typename... T> using void_t = typename void_t_impl<T...>::type; -#else -template <typename...> using void_t = void; -#endif - -template <typename It, typename T, typename Enable = void> -struct is_output_iterator : std::false_type {}; - -template <typename It, typename T> -struct is_output_iterator< - It, T, - void_t<typename std::iterator_traits<It>::iterator_category, - decltype(*std::declval<It>() = std::declval<T>())>> - : std::true_type {}; - -template <typename It> struct is_back_insert_iterator : std::false_type {}; -template <typename Container> -struct is_back_insert_iterator<std::back_insert_iterator<Container>> - : std::true_type {}; - -template <typename It> -struct is_contiguous_back_insert_iterator : std::false_type {}; -template <typename Container> -struct is_contiguous_back_insert_iterator<std::back_insert_iterator<Container>> - : is_contiguous<Container> {}; -template <> -struct is_contiguous_back_insert_iterator<appender> : std::true_type {}; - -// A type-erased reference to an std::locale to avoid a heavy <locale> include. -class locale_ref { - private: - const void* locale_; // A type-erased pointer to std::locale. - - public: - constexpr FMT_INLINE locale_ref() : locale_(nullptr) {} - template <typename Locale> explicit locale_ref(const Locale& loc); - - explicit operator bool() const noexcept { return locale_ != nullptr; } - - template <typename Locale> auto get() const -> Locale; -}; - -template <typename> constexpr auto encode_types() -> unsigned long long { - return 0; -} - -template <typename Context, typename Arg, typename... Args> -constexpr auto encode_types() -> unsigned long long { - return static_cast<unsigned>(mapped_type_constant<Arg, Context>::value) | - (encode_types<Context, Args...>() << packed_arg_bits); -} - -template <typename Context, typename T> -FMT_CONSTEXPR FMT_INLINE auto make_value(T&& val) -> value<Context> { - auto&& arg = arg_mapper<Context>().map(FMT_FORWARD(val)); - using arg_type = remove_cvref_t<decltype(arg)>; - - constexpr bool formattable_char = - !std::is_same<arg_type, unformattable_char>::value; - static_assert(formattable_char, "Mixing character types is disallowed."); - - // Formatting of arbitrary pointers is disallowed. If you want to format a - // pointer cast it to `void*` or `const void*`. In particular, this forbids - // formatting of `[const] volatile char*` printed as bool by iostreams. - constexpr bool formattable_pointer = - !std::is_same<arg_type, unformattable_pointer>::value; - static_assert(formattable_pointer, - "Formatting of non-void pointers is disallowed."); - - constexpr bool formattable = !std::is_same<arg_type, unformattable>::value; - static_assert( - formattable, - "Cannot format an argument. To make type T formattable provide a " - "formatter<T> specialization: https://fmt.dev/latest/api.html#udt"); - return {arg}; -} - -template <typename Context, typename T> -FMT_CONSTEXPR auto make_arg(T&& value) -> basic_format_arg<Context> { - auto arg = basic_format_arg<Context>(); - arg.type_ = mapped_type_constant<T, Context>::value; - arg.value_ = make_value<Context>(value); - return arg; -} - -// The DEPRECATED type template parameter is there to avoid an ODR violation -// when using a fallback formatter in one translation unit and an implicit -// conversion in another (not recommended). -template <bool IS_PACKED, typename Context, type, typename T, - FMT_ENABLE_IF(IS_PACKED)> -FMT_CONSTEXPR FMT_INLINE auto make_arg(T&& val) -> value<Context> { - return make_value<Context>(val); -} - -template <bool IS_PACKED, typename Context, type, typename T, - FMT_ENABLE_IF(!IS_PACKED)> -FMT_CONSTEXPR inline auto make_arg(T&& value) -> basic_format_arg<Context> { - return make_arg<Context>(value); -} -} // namespace detail -FMT_BEGIN_EXPORT - -// Formatting context. -template <typename OutputIt, typename Char> class basic_format_context { - private: - OutputIt out_; - basic_format_args<basic_format_context> args_; - detail::locale_ref loc_; - - public: - using iterator = OutputIt; - using format_arg = basic_format_arg<basic_format_context>; - using format_args = basic_format_args<basic_format_context>; - using parse_context_type = basic_format_parse_context<Char>; - template <typename T> using formatter_type = formatter<T, Char>; - - /** The character type for the output. */ - using char_type = Char; - - basic_format_context(basic_format_context&&) = default; - basic_format_context(const basic_format_context&) = delete; - void operator=(const basic_format_context&) = delete; - /** - Constructs a ``basic_format_context`` object. References to the arguments - are stored in the object so make sure they have appropriate lifetimes. - */ - constexpr basic_format_context(OutputIt out, format_args ctx_args, - detail::locale_ref loc = {}) - : out_(out), args_(ctx_args), loc_(loc) {} - - constexpr auto arg(int id) const -> format_arg { return args_.get(id); } - FMT_CONSTEXPR auto arg(basic_string_view<Char> name) -> format_arg { - return args_.get(name); - } - FMT_CONSTEXPR auto arg_id(basic_string_view<Char> name) -> int { - return args_.get_id(name); - } - auto args() const -> const format_args& { return args_; } - - FMT_CONSTEXPR auto error_handler() -> detail::error_handler { return {}; } - void on_error(const char* message) { error_handler().on_error(message); } - - // Returns an iterator to the beginning of the output range. - FMT_CONSTEXPR auto out() -> iterator { return out_; } - - // Advances the begin iterator to ``it``. - void advance_to(iterator it) { - if (!detail::is_back_insert_iterator<iterator>()) out_ = it; - } - - FMT_CONSTEXPR auto locale() -> detail::locale_ref { return loc_; } -}; - -template <typename Char> -using buffer_context = - basic_format_context<detail::buffer_appender<Char>, Char>; -using format_context = buffer_context<char>; - -template <typename T, typename Char = char> -using is_formattable = bool_constant<!std::is_base_of< - detail::unformattable, decltype(detail::arg_mapper<buffer_context<Char>>() - .map(std::declval<T>()))>::value>; - -/** - \rst - An array of references to arguments. It can be implicitly converted into - `~fmt::basic_format_args` for passing into type-erased formatting functions - such as `~fmt::vformat`. - \endrst - */ -template <typename Context, typename... Args> -class format_arg_store -#if FMT_GCC_VERSION && FMT_GCC_VERSION < 409 - // Workaround a GCC template argument substitution bug. - : public basic_format_args<Context> -#endif -{ - private: - static const size_t num_args = sizeof...(Args); - static const size_t num_named_args = detail::count_named_args<Args...>(); - static const bool is_packed = num_args <= detail::max_packed_args; - - using value_type = conditional_t<is_packed, detail::value<Context>, - basic_format_arg<Context>>; - - detail::arg_data<value_type, typename Context::char_type, num_args, - num_named_args> - data_; - - friend class basic_format_args<Context>; - - static constexpr unsigned long long desc = - (is_packed ? detail::encode_types<Context, Args...>() - : detail::is_unpacked_bit | num_args) | - (num_named_args != 0 - ? static_cast<unsigned long long>(detail::has_named_args_bit) - : 0); - - public: - template <typename... T> - FMT_CONSTEXPR FMT_INLINE format_arg_store(T&&... args) - : -#if FMT_GCC_VERSION && FMT_GCC_VERSION < 409 - basic_format_args<Context>(*this), -#endif - data_{detail::make_arg< - is_packed, Context, - detail::mapped_type_constant<remove_cvref_t<T>, Context>::value>( - FMT_FORWARD(args))...} { - detail::init_named_args(data_.named_args(), 0, 0, args...); - } -}; - -/** - \rst - Constructs a `~fmt::format_arg_store` object that contains references to - arguments and can be implicitly converted to `~fmt::format_args`. `Context` - can be omitted in which case it defaults to `~fmt::context`. - See `~fmt::arg` for lifetime considerations. - \endrst - */ -template <typename Context = format_context, typename... T> -constexpr auto make_format_args(T&&... args) - -> format_arg_store<Context, remove_cvref_t<T>...> { - return {FMT_FORWARD(args)...}; -} - -/** - \rst - Returns a named argument to be used in a formatting function. - It should only be used in a call to a formatting function or - `dynamic_format_arg_store::push_back`. - - **Example**:: - - fmt::print("Elapsed time: {s:.2f} seconds", fmt::arg("s", 1.23)); - \endrst - */ -template <typename Char, typename T> -inline auto arg(const Char* name, const T& arg) -> detail::named_arg<Char, T> { - static_assert(!detail::is_named_arg<T>(), "nested named arguments"); - return {name, arg}; -} -FMT_END_EXPORT - -/** - \rst - A view of a collection of formatting arguments. To avoid lifetime issues it - should only be used as a parameter type in type-erased functions such as - ``vformat``:: - - void vlog(string_view format_str, format_args args); // OK - format_args args = make_format_args(42); // Error: dangling reference - \endrst - */ -template <typename Context> class basic_format_args { - public: - using size_type = int; - using format_arg = basic_format_arg<Context>; - - private: - // A descriptor that contains information about formatting arguments. - // If the number of arguments is less or equal to max_packed_args then - // argument types are passed in the descriptor. This reduces binary code size - // per formatting function call. - unsigned long long desc_; - union { - // If is_packed() returns true then argument values are stored in values_; - // otherwise they are stored in args_. This is done to improve cache - // locality and reduce compiled code size since storing larger objects - // may require more code (at least on x86-64) even if the same amount of - // data is actually copied to stack. It saves ~10% on the bloat test. - const detail::value<Context>* values_; - const format_arg* args_; - }; - - constexpr auto is_packed() const -> bool { - return (desc_ & detail::is_unpacked_bit) == 0; - } - auto has_named_args() const -> bool { - return (desc_ & detail::has_named_args_bit) != 0; - } - - FMT_CONSTEXPR auto type(int index) const -> detail::type { - int shift = index * detail::packed_arg_bits; - unsigned int mask = (1 << detail::packed_arg_bits) - 1; - return static_cast<detail::type>((desc_ >> shift) & mask); - } - - constexpr FMT_INLINE basic_format_args(unsigned long long desc, - const detail::value<Context>* values) - : desc_(desc), values_(values) {} - constexpr basic_format_args(unsigned long long desc, const format_arg* args) - : desc_(desc), args_(args) {} - - public: - constexpr basic_format_args() : desc_(0), args_(nullptr) {} - - /** - \rst - Constructs a `basic_format_args` object from `~fmt::format_arg_store`. - \endrst - */ - template <typename... Args> - constexpr FMT_INLINE basic_format_args( - const format_arg_store<Context, Args...>& store) - : basic_format_args(format_arg_store<Context, Args...>::desc, - store.data_.args()) {} - - /** - \rst - Constructs a `basic_format_args` object from - `~fmt::dynamic_format_arg_store`. - \endrst - */ - constexpr FMT_INLINE basic_format_args( - const dynamic_format_arg_store<Context>& store) - : basic_format_args(store.get_types(), store.data()) {} - - /** - \rst - Constructs a `basic_format_args` object from a dynamic set of arguments. - \endrst - */ - constexpr basic_format_args(const format_arg* args, int count) - : basic_format_args(detail::is_unpacked_bit | detail::to_unsigned(count), - args) {} - - /** Returns the argument with the specified id. */ - FMT_CONSTEXPR auto get(int id) const -> format_arg { - format_arg arg; - if (!is_packed()) { - if (id < max_size()) arg = args_[id]; - return arg; - } - if (id >= detail::max_packed_args) return arg; - arg.type_ = type(id); - if (arg.type_ == detail::type::none_type) return arg; - arg.value_ = values_[id]; - return arg; - } - - template <typename Char> - auto get(basic_string_view<Char> name) const -> format_arg { - int id = get_id(name); - return id >= 0 ? get(id) : format_arg(); - } - - template <typename Char> - auto get_id(basic_string_view<Char> name) const -> int { - if (!has_named_args()) return -1; - const auto& named_args = - (is_packed() ? values_[-1] : args_[-1].value_).named_args; - for (size_t i = 0; i < named_args.size; ++i) { - if (named_args.data[i].name == name) return named_args.data[i].id; - } - return -1; - } - - auto max_size() const -> int { - unsigned long long max_packed = detail::max_packed_args; - return static_cast<int>(is_packed() ? max_packed - : desc_ & ~detail::is_unpacked_bit); - } -}; - -/** An alias to ``basic_format_args<format_context>``. */ -// A separate type would result in shorter symbols but break ABI compatibility -// between clang and gcc on ARM (#1919). -FMT_MODULE_EXPORT using format_args = basic_format_args<format_context>; - -// We cannot use enum classes as bit fields because of a gcc bug, so we put them -// in namespaces instead (https://gcc.gnu.org/bugzilla/show_bug.cgi?id=61414). -// Additionally, if an underlying type is specified, older gcc incorrectly warns -// that the type is too small. Both bugs are fixed in gcc 9.3. -#if FMT_GCC_VERSION && FMT_GCC_VERSION < 903 -# define FMT_ENUM_UNDERLYING_TYPE(type) -#else -# define FMT_ENUM_UNDERLYING_TYPE(type) : type -#endif -namespace align { -enum type FMT_ENUM_UNDERLYING_TYPE(unsigned char){none, left, right, center, - numeric}; -} -using align_t = align::type; -namespace sign { -enum type FMT_ENUM_UNDERLYING_TYPE(unsigned char){none, minus, plus, space}; -} -using sign_t = sign::type; - -namespace detail { - -// Workaround an array initialization issue in gcc 4.8. -template <typename Char> struct fill_t { - private: - enum { max_size = 4 }; - Char data_[max_size] = {Char(' '), Char(0), Char(0), Char(0)}; - unsigned char size_ = 1; - - public: - FMT_CONSTEXPR void operator=(basic_string_view<Char> s) { - auto size = s.size(); - FMT_ASSERT(size <= max_size, "invalid fill"); - for (size_t i = 0; i < size; ++i) data_[i] = s[i]; - size_ = static_cast<unsigned char>(size); - } - - constexpr auto size() const -> size_t { return size_; } - constexpr auto data() const -> const Char* { return data_; } - - FMT_CONSTEXPR auto operator[](size_t index) -> Char& { return data_[index]; } - FMT_CONSTEXPR auto operator[](size_t index) const -> const Char& { - return data_[index]; - } -}; -} // namespace detail - -enum class presentation_type : unsigned char { - none, - dec, // 'd' - oct, // 'o' - hex_lower, // 'x' - hex_upper, // 'X' - bin_lower, // 'b' - bin_upper, // 'B' - hexfloat_lower, // 'a' - hexfloat_upper, // 'A' - exp_lower, // 'e' - exp_upper, // 'E' - fixed_lower, // 'f' - fixed_upper, // 'F' - general_lower, // 'g' - general_upper, // 'G' - chr, // 'c' - string, // 's' - pointer, // 'p' - debug // '?' -}; - -// Format specifiers for built-in and string types. -template <typename Char = char> struct format_specs { - int width; - int precision; - presentation_type type; - align_t align : 4; - sign_t sign : 3; - bool alt : 1; // Alternate form ('#'). - bool localized : 1; - detail::fill_t<Char> fill; - - constexpr format_specs() - : width(0), - precision(-1), - type(presentation_type::none), - align(align::none), - sign(sign::none), - alt(false), - localized(false) {} -}; - -namespace detail { - -enum class arg_id_kind { none, index, name }; - -// An argument reference. -template <typename Char> struct arg_ref { - FMT_CONSTEXPR arg_ref() : kind(arg_id_kind::none), val() {} - - FMT_CONSTEXPR explicit arg_ref(int index) - : kind(arg_id_kind::index), val(index) {} - FMT_CONSTEXPR explicit arg_ref(basic_string_view<Char> name) - : kind(arg_id_kind::name), val(name) {} - - FMT_CONSTEXPR auto operator=(int idx) -> arg_ref& { - kind = arg_id_kind::index; - val.index = idx; - return *this; - } - - arg_id_kind kind; - union value { - FMT_CONSTEXPR value(int idx = 0) : index(idx) {} - FMT_CONSTEXPR value(basic_string_view<Char> n) : name(n) {} - - int index; - basic_string_view<Char> name; - } val; -}; - -// Format specifiers with width and precision resolved at formatting rather -// than parsing time to allow reusing the same parsed specifiers with -// different sets of arguments (precompilation of format strings). -template <typename Char = char> -struct dynamic_format_specs : format_specs<Char> { - arg_ref<Char> width_ref; - arg_ref<Char> precision_ref; -}; - -// Converts a character to ASCII. Returns '\0' on conversion failure. -template <typename Char, FMT_ENABLE_IF(std::is_integral<Char>::value)> -constexpr auto to_ascii(Char c) -> char { - return c <= 0xff ? static_cast<char>(c) : '\0'; -} -template <typename Char, FMT_ENABLE_IF(std::is_enum<Char>::value)> -constexpr auto to_ascii(Char c) -> char { - return c <= 0xff ? static_cast<char>(c) : '\0'; -} - -// Returns the number of code units in a code point or 1 on error. -template <typename Char> -FMT_CONSTEXPR auto code_point_length(const Char* begin) -> int { - if (const_check(sizeof(Char) != 1)) return 1; - auto c = static_cast<unsigned char>(*begin); - return static_cast<int>((0x3a55000000000000ull >> (2 * (c >> 3))) & 0x3) + 1; -} - -// Return the result via the out param to workaround gcc bug 77539. -template <bool IS_CONSTEXPR, typename T, typename Ptr = const T*> -FMT_CONSTEXPR auto find(Ptr first, Ptr last, T value, Ptr& out) -> bool { - for (out = first; out != last; ++out) { - if (*out == value) return true; - } - return false; -} - -template <> -inline auto find<false, char>(const char* first, const char* last, char value, - const char*& out) -> bool { - out = static_cast<const char*>( - std::memchr(first, value, to_unsigned(last - first))); - return out != nullptr; -} - -// Parses the range [begin, end) as an unsigned integer. This function assumes -// that the range is non-empty and the first character is a digit. -template <typename Char> -FMT_CONSTEXPR auto parse_nonnegative_int(const Char*& begin, const Char* end, - int error_value) noexcept -> int { - FMT_ASSERT(begin != end && '0' <= *begin && *begin <= '9', ""); - unsigned value = 0, prev = 0; - auto p = begin; - do { - prev = value; - value = value * 10 + unsigned(*p - '0'); - ++p; - } while (p != end && '0' <= *p && *p <= '9'); - auto num_digits = p - begin; - begin = p; - if (num_digits <= std::numeric_limits<int>::digits10) - return static_cast<int>(value); - // Check for overflow. - const unsigned max = to_unsigned((std::numeric_limits<int>::max)()); - return num_digits == std::numeric_limits<int>::digits10 + 1 && - prev * 10ull + unsigned(p[-1] - '0') <= max - ? static_cast<int>(value) - : error_value; -} - -FMT_CONSTEXPR inline auto parse_align(char c) -> align_t { - switch (c) { - case '<': - return align::left; - case '>': - return align::right; - case '^': - return align::center; - } - return align::none; -} - -template <typename Char> constexpr auto is_name_start(Char c) -> bool { - return ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z') || c == '_'; -} - -template <typename Char, typename Handler> -FMT_CONSTEXPR auto do_parse_arg_id(const Char* begin, const Char* end, - Handler&& handler) -> const Char* { - Char c = *begin; - if (c >= '0' && c <= '9') { - int index = 0; - constexpr int max = (std::numeric_limits<int>::max)(); - if (c != '0') - index = parse_nonnegative_int(begin, end, max); - else - ++begin; - if (begin == end || (*begin != '}' && *begin != ':')) - throw_format_error("invalid format string"); - else - handler.on_index(index); - return begin; - } - if (!is_name_start(c)) { - throw_format_error("invalid format string"); - return begin; - } - auto it = begin; - do { - ++it; - } while (it != end && (is_name_start(*it) || ('0' <= *it && *it <= '9'))); - handler.on_name({begin, to_unsigned(it - begin)}); - return it; -} - -template <typename Char, typename Handler> -FMT_CONSTEXPR FMT_INLINE auto parse_arg_id(const Char* begin, const Char* end, - Handler&& handler) -> const Char* { - FMT_ASSERT(begin != end, ""); - Char c = *begin; - if (c != '}' && c != ':') return do_parse_arg_id(begin, end, handler); - handler.on_auto(); - return begin; -} - -template <typename Char> struct dynamic_spec_id_handler { - basic_format_parse_context<Char>& ctx; - arg_ref<Char>& ref; - - FMT_CONSTEXPR void on_auto() { - int id = ctx.next_arg_id(); - ref = arg_ref<Char>(id); - ctx.check_dynamic_spec(id); - } - FMT_CONSTEXPR void on_index(int id) { - ref = arg_ref<Char>(id); - ctx.check_arg_id(id); - ctx.check_dynamic_spec(id); - } - FMT_CONSTEXPR void on_name(basic_string_view<Char> id) { - ref = arg_ref<Char>(id); - ctx.check_arg_id(id); - } -}; - -// Parses [integer | "{" [arg_id] "}"]. -template <typename Char> -FMT_CONSTEXPR auto parse_dynamic_spec(const Char* begin, const Char* end, - int& value, arg_ref<Char>& ref, - basic_format_parse_context<Char>& ctx) - -> const Char* { - FMT_ASSERT(begin != end, ""); - if ('0' <= *begin && *begin <= '9') { - int val = parse_nonnegative_int(begin, end, -1); - if (val != -1) - value = val; - else - throw_format_error("number is too big"); - } else if (*begin == '{') { - ++begin; - auto handler = dynamic_spec_id_handler<Char>{ctx, ref}; - if (begin != end) begin = parse_arg_id(begin, end, handler); - if (begin != end && *begin == '}') return ++begin; - throw_format_error("invalid format string"); - } - return begin; -} - -template <typename Char> -FMT_CONSTEXPR auto parse_precision(const Char* begin, const Char* end, - int& value, arg_ref<Char>& ref, - basic_format_parse_context<Char>& ctx) - -> const Char* { - ++begin; - if (begin == end || *begin == '}') { - throw_format_error("invalid precision"); - return begin; - } - return parse_dynamic_spec(begin, end, value, ref, ctx); -} - -enum class state { start, align, sign, hash, zero, width, precision, locale }; - -// Parses standard format specifiers. -template <typename Char> -FMT_CONSTEXPR FMT_INLINE auto parse_format_specs( - const Char* begin, const Char* end, dynamic_format_specs<Char>& specs, - basic_format_parse_context<Char>& ctx, type arg_type) -> const Char* { - auto c = '\0'; - if (end - begin > 1) { - auto next = to_ascii(begin[1]); - c = parse_align(next) == align::none ? to_ascii(*begin) : '\0'; - } else { - if (begin == end) return begin; - c = to_ascii(*begin); - } - - struct { - state current_state = state::start; - FMT_CONSTEXPR void operator()(state s, bool valid = true) { - if (current_state >= s || !valid) - throw_format_error("invalid format specifier"); - current_state = s; - } - } enter_state; - - using pres = presentation_type; - constexpr auto integral_set = sint_set | uint_set | bool_set | char_set; - struct { - const Char*& begin; - dynamic_format_specs<Char>& specs; - type arg_type; - - FMT_CONSTEXPR auto operator()(pres type, int set) -> const Char* { - if (!in(arg_type, set)) throw_format_error("invalid format specifier"); - specs.type = type; - return begin + 1; - } - } parse_presentation_type{begin, specs, arg_type}; - - for (;;) { - switch (c) { - case '<': - case '>': - case '^': - enter_state(state::align); - specs.align = parse_align(c); - ++begin; - break; - case '+': - case '-': - case ' ': - enter_state(state::sign, in(arg_type, sint_set | float_set)); - switch (c) { - case '+': - specs.sign = sign::plus; - break; - case '-': - specs.sign = sign::minus; - break; - case ' ': - specs.sign = sign::space; - break; - } - ++begin; - break; - case '#': - enter_state(state::hash, is_arithmetic_type(arg_type)); - specs.alt = true; - ++begin; - break; - case '0': - enter_state(state::zero); - if (!is_arithmetic_type(arg_type)) - throw_format_error("format specifier requires numeric argument"); - if (specs.align == align::none) { - // Ignore 0 if align is specified for compatibility with std::format. - specs.align = align::numeric; - specs.fill[0] = Char('0'); - } - ++begin; - break; - case '1': - case '2': - case '3': - case '4': - case '5': - case '6': - case '7': - case '8': - case '9': - case '{': - enter_state(state::width); - begin = parse_dynamic_spec(begin, end, specs.width, specs.width_ref, ctx); - break; - case '.': - enter_state(state::precision, - in(arg_type, float_set | string_set | cstring_set)); - begin = parse_precision(begin, end, specs.precision, specs.precision_ref, - ctx); - break; - case 'L': - enter_state(state::locale, is_arithmetic_type(arg_type)); - specs.localized = true; - ++begin; - break; - case 'd': - return parse_presentation_type(pres::dec, integral_set); - case 'o': - return parse_presentation_type(pres::oct, integral_set); - case 'x': - return parse_presentation_type(pres::hex_lower, integral_set); - case 'X': - return parse_presentation_type(pres::hex_upper, integral_set); - case 'b': - return parse_presentation_type(pres::bin_lower, integral_set); - case 'B': - return parse_presentation_type(pres::bin_upper, integral_set); - case 'a': - return parse_presentation_type(pres::hexfloat_lower, float_set); - case 'A': - return parse_presentation_type(pres::hexfloat_upper, float_set); - case 'e': - return parse_presentation_type(pres::exp_lower, float_set); - case 'E': - return parse_presentation_type(pres::exp_upper, float_set); - case 'f': - return parse_presentation_type(pres::fixed_lower, float_set); - case 'F': - return parse_presentation_type(pres::fixed_upper, float_set); - case 'g': - return parse_presentation_type(pres::general_lower, float_set); - case 'G': - return parse_presentation_type(pres::general_upper, float_set); - case 'c': - return parse_presentation_type(pres::chr, integral_set); - case 's': - return parse_presentation_type(pres::string, - bool_set | string_set | cstring_set); - case 'p': - return parse_presentation_type(pres::pointer, pointer_set | cstring_set); - case '?': - return parse_presentation_type(pres::debug, - char_set | string_set | cstring_set); - case '}': - return begin; - default: { - if (*begin == '}') return begin; - // Parse fill and alignment. - auto fill_end = begin + code_point_length(begin); - if (end - fill_end <= 0) { - throw_format_error("invalid format specifier"); - return begin; - } - if (*begin == '{') { - throw_format_error("invalid fill character '{'"); - return begin; - } - auto align = parse_align(to_ascii(*fill_end)); - enter_state(state::align, align != align::none); - specs.fill = {begin, to_unsigned(fill_end - begin)}; - specs.align = align; - begin = fill_end + 1; - } - } - if (begin == end) return begin; - c = to_ascii(*begin); - } -} - -template <typename Char, typename Handler> -FMT_CONSTEXPR auto parse_replacement_field(const Char* begin, const Char* end, - Handler&& handler) -> const Char* { - struct id_adapter { - Handler& handler; - int arg_id; - - FMT_CONSTEXPR void on_auto() { arg_id = handler.on_arg_id(); } - FMT_CONSTEXPR void on_index(int id) { arg_id = handler.on_arg_id(id); } - FMT_CONSTEXPR void on_name(basic_string_view<Char> id) { - arg_id = handler.on_arg_id(id); - } - }; - - ++begin; - if (begin == end) return handler.on_error("invalid format string"), end; - if (*begin == '}') { - handler.on_replacement_field(handler.on_arg_id(), begin); - } else if (*begin == '{') { - handler.on_text(begin, begin + 1); - } else { - auto adapter = id_adapter{handler, 0}; - begin = parse_arg_id(begin, end, adapter); - Char c = begin != end ? *begin : Char(); - if (c == '}') { - handler.on_replacement_field(adapter.arg_id, begin); - } else if (c == ':') { - begin = handler.on_format_specs(adapter.arg_id, begin + 1, end); - if (begin == end || *begin != '}') - return handler.on_error("unknown format specifier"), end; - } else { - return handler.on_error("missing '}' in format string"), end; - } - } - return begin + 1; -} - -template <bool IS_CONSTEXPR, typename Char, typename Handler> -FMT_CONSTEXPR FMT_INLINE void parse_format_string( - basic_string_view<Char> format_str, Handler&& handler) { - auto begin = format_str.data(); - auto end = begin + format_str.size(); - if (end - begin < 32) { - // Use a simple loop instead of memchr for small strings. - const Char* p = begin; - while (p != end) { - auto c = *p++; - if (c == '{') { - handler.on_text(begin, p - 1); - begin = p = parse_replacement_field(p - 1, end, handler); - } else if (c == '}') { - if (p == end || *p != '}') - return handler.on_error("unmatched '}' in format string"); - handler.on_text(begin, p); - begin = ++p; - } - } - handler.on_text(begin, end); - return; - } - struct writer { - FMT_CONSTEXPR void operator()(const Char* from, const Char* to) { - if (from == to) return; - for (;;) { - const Char* p = nullptr; - if (!find<IS_CONSTEXPR>(from, to, Char('}'), p)) - return handler_.on_text(from, to); - ++p; - if (p == to || *p != '}') - return handler_.on_error("unmatched '}' in format string"); - handler_.on_text(from, p); - from = p + 1; - } - } - Handler& handler_; - } write = {handler}; - while (begin != end) { - // Doing two passes with memchr (one for '{' and another for '}') is up to - // 2.5x faster than the naive one-pass implementation on big format strings. - const Char* p = begin; - if (*begin != '{' && !find<IS_CONSTEXPR>(begin + 1, end, Char('{'), p)) - return write(begin, end); - write(begin, p); - begin = parse_replacement_field(p, end, handler); - } -} - -template <typename T, bool = is_named_arg<T>::value> struct strip_named_arg { - using type = T; -}; -template <typename T> struct strip_named_arg<T, true> { - using type = remove_cvref_t<decltype(T::value)>; -}; - -template <typename T, typename ParseContext> -FMT_CONSTEXPR auto parse_format_specs(ParseContext& ctx) - -> decltype(ctx.begin()) { - using char_type = typename ParseContext::char_type; - using context = buffer_context<char_type>; - using mapped_type = conditional_t< - mapped_type_constant<T, context>::value != type::custom_type, - decltype(arg_mapper<context>().map(std::declval<const T&>())), - typename strip_named_arg<T>::type>; - return formatter<mapped_type, char_type>().parse(ctx); -} - -// Checks char specs and returns true iff the presentation type is char-like. -template <typename Char> -FMT_CONSTEXPR auto check_char_specs(const format_specs<Char>& specs) -> bool { - if (specs.type != presentation_type::none && - specs.type != presentation_type::chr && - specs.type != presentation_type::debug) { - return false; - } - if (specs.align == align::numeric || specs.sign != sign::none || specs.alt) - throw_format_error("invalid format specifier for char"); - return true; -} - -constexpr FMT_INLINE_VARIABLE int invalid_arg_index = -1; - -#if FMT_USE_NONTYPE_TEMPLATE_ARGS -template <int N, typename T, typename... Args, typename Char> -constexpr auto get_arg_index_by_name(basic_string_view<Char> name) -> int { - if constexpr (is_statically_named_arg<T>()) { - if (name == T::name) return N; - } - if constexpr (sizeof...(Args) > 0) - return get_arg_index_by_name<N + 1, Args...>(name); - (void)name; // Workaround an MSVC bug about "unused" parameter. - return invalid_arg_index; -} -#endif - -template <typename... Args, typename Char> -FMT_CONSTEXPR auto get_arg_index_by_name(basic_string_view<Char> name) -> int { -#if FMT_USE_NONTYPE_TEMPLATE_ARGS - if constexpr (sizeof...(Args) > 0) - return get_arg_index_by_name<0, Args...>(name); -#endif - (void)name; - return invalid_arg_index; -} - -template <typename Char, typename... Args> class format_string_checker { - private: - using parse_context_type = compile_parse_context<Char>; - static constexpr int num_args = sizeof...(Args); - - // Format specifier parsing function. - // In the future basic_format_parse_context will replace compile_parse_context - // here and will use is_constant_evaluated and downcasting to access the data - // needed for compile-time checks: https://godbolt.org/z/GvWzcTjh1. - using parse_func = const Char* (*)(parse_context_type&); - - parse_context_type context_; - parse_func parse_funcs_[num_args > 0 ? static_cast<size_t>(num_args) : 1]; - type types_[num_args > 0 ? static_cast<size_t>(num_args) : 1]; - - public: - explicit FMT_CONSTEXPR format_string_checker(basic_string_view<Char> fmt) - : context_(fmt, num_args, types_), - parse_funcs_{&parse_format_specs<Args, parse_context_type>...}, - types_{mapped_type_constant<Args, buffer_context<Char>>::value...} {} - - FMT_CONSTEXPR void on_text(const Char*, const Char*) {} - - FMT_CONSTEXPR auto on_arg_id() -> int { return context_.next_arg_id(); } - FMT_CONSTEXPR auto on_arg_id(int id) -> int { - return context_.check_arg_id(id), id; - } - FMT_CONSTEXPR auto on_arg_id(basic_string_view<Char> id) -> int { -#if FMT_USE_NONTYPE_TEMPLATE_ARGS - auto index = get_arg_index_by_name<Args...>(id); - if (index == invalid_arg_index) on_error("named argument is not found"); - return index; -#else - (void)id; - on_error("compile-time checks for named arguments require C++20 support"); - return 0; -#endif - } - - FMT_CONSTEXPR void on_replacement_field(int, const Char*) {} - - FMT_CONSTEXPR auto on_format_specs(int id, const Char* begin, const Char*) - -> const Char* { - context_.advance_to(begin); - // id >= 0 check is a workaround for gcc 10 bug (#2065). - return id >= 0 && id < num_args ? parse_funcs_[id](context_) : begin; - } - - FMT_CONSTEXPR void on_error(const char* message) { - throw_format_error(message); - } -}; - -// Reports a compile-time error if S is not a valid format string. -template <typename..., typename S, FMT_ENABLE_IF(!is_compile_string<S>::value)> -FMT_INLINE void check_format_string(const S&) { -#ifdef FMT_ENFORCE_COMPILE_STRING - static_assert(is_compile_string<S>::value, - "FMT_ENFORCE_COMPILE_STRING requires all format strings to use " - "FMT_STRING."); -#endif -} -template <typename... Args, typename S, - FMT_ENABLE_IF(is_compile_string<S>::value)> -void check_format_string(S format_str) { - using char_t = typename S::char_type; - FMT_CONSTEXPR auto s = basic_string_view<char_t>(format_str); - using checker = format_string_checker<char_t, remove_cvref_t<Args>...>; - FMT_CONSTEXPR bool error = (parse_format_string<true>(s, checker(s)), true); - ignore_unused(error); -} - -template <typename Char = char> struct vformat_args { - using type = basic_format_args< - basic_format_context<std::back_insert_iterator<buffer<Char>>, Char>>; -}; -template <> struct vformat_args<char> { using type = format_args; }; - -// Use vformat_args and avoid type_identity to keep symbols short. -template <typename Char> -void vformat_to(buffer<Char>& buf, basic_string_view<Char> fmt, - typename vformat_args<Char>::type args, locale_ref loc = {}); - -FMT_API void vprint_mojibake(std::FILE*, string_view, format_args); -#ifndef _WIN32 -inline void vprint_mojibake(std::FILE*, string_view, format_args) {} -#endif -} // namespace detail - -FMT_BEGIN_EXPORT - -// A formatter specialization for natively supported types. -template <typename T, typename Char> -struct formatter<T, Char, - enable_if_t<detail::type_constant<T, Char>::value != - detail::type::custom_type>> { - private: - detail::dynamic_format_specs<Char> specs_; - - public: - template <typename ParseContext> - FMT_CONSTEXPR auto parse(ParseContext& ctx) -> const Char* { - auto type = detail::type_constant<T, Char>::value; - auto end = - detail::parse_format_specs(ctx.begin(), ctx.end(), specs_, ctx, type); - if (type == detail::type::char_type) detail::check_char_specs(specs_); - return end; - } - - template <detail::type U = detail::type_constant<T, Char>::value, - FMT_ENABLE_IF(U == detail::type::string_type || - U == detail::type::cstring_type || - U == detail::type::char_type)> - FMT_CONSTEXPR void set_debug_format(bool set = true) { - specs_.type = set ? presentation_type::debug : presentation_type::none; - } - - template <typename FormatContext> - FMT_CONSTEXPR auto format(const T& val, FormatContext& ctx) const - -> decltype(ctx.out()); -}; - -#define FMT_FORMAT_AS(Type, Base) \ - template <typename Char> \ - struct formatter<Type, Char> : formatter<Base, Char> { \ - template <typename FormatContext> \ - auto format(const Type& val, FormatContext& ctx) const \ - -> decltype(ctx.out()) { \ - return formatter<Base, Char>::format(static_cast<Base>(val), ctx); \ - } \ - } - -FMT_FORMAT_AS(signed char, int); -FMT_FORMAT_AS(unsigned char, unsigned); -FMT_FORMAT_AS(short, int); -FMT_FORMAT_AS(unsigned short, unsigned); -FMT_FORMAT_AS(long, long long); -FMT_FORMAT_AS(unsigned long, unsigned long long); -FMT_FORMAT_AS(Char*, const Char*); -FMT_FORMAT_AS(std::basic_string<Char>, basic_string_view<Char>); -FMT_FORMAT_AS(std::nullptr_t, const void*); -FMT_FORMAT_AS(detail::std_string_view<Char>, basic_string_view<Char>); - -template <typename Char = char> struct runtime_format_string { - basic_string_view<Char> str; -}; - -/** A compile-time format string. */ -template <typename Char, typename... Args> class basic_format_string { - private: - basic_string_view<Char> str_; - - public: - template <typename S, - FMT_ENABLE_IF( - std::is_convertible<const S&, basic_string_view<Char>>::value)> - FMT_CONSTEVAL FMT_INLINE basic_format_string(const S& s) : str_(s) { - static_assert( - detail::count< - (std::is_base_of<detail::view, remove_reference_t<Args>>::value && - std::is_reference<Args>::value)...>() == 0, - "passing views as lvalues is disallowed"); -#ifdef FMT_HAS_CONSTEVAL - if constexpr (detail::count_named_args<Args...>() == - detail::count_statically_named_args<Args...>()) { - using checker = - detail::format_string_checker<Char, remove_cvref_t<Args>...>; - detail::parse_format_string<true>(str_, checker(s)); - } -#else - detail::check_format_string<Args...>(s); -#endif - } - basic_format_string(runtime_format_string<Char> fmt) : str_(fmt.str) {} - - FMT_INLINE operator basic_string_view<Char>() const { return str_; } - FMT_INLINE auto get() const -> basic_string_view<Char> { return str_; } -}; - -#if FMT_GCC_VERSION && FMT_GCC_VERSION < 409 -// Workaround broken conversion on older gcc. -template <typename...> using format_string = string_view; -inline auto runtime(string_view s) -> string_view { return s; } -#else -template <typename... Args> -using format_string = basic_format_string<char, type_identity_t<Args>...>; -/** - \rst - Creates a runtime format string. - - **Example**:: - - // Check format string at runtime instead of compile-time. - fmt::print(fmt::runtime("{:d}"), "I am not a number"); - \endrst - */ -inline auto runtime(string_view s) -> runtime_format_string<> { return {{s}}; } -#endif - -FMT_API auto vformat(string_view fmt, format_args args) -> std::string; - -/** - \rst - Formats ``args`` according to specifications in ``fmt`` and returns the result - as a string. - - **Example**:: - - #include <fmt/core.h> - std::string message = fmt::format("The answer is {}.", 42); - \endrst -*/ -template <typename... T> -FMT_NODISCARD FMT_INLINE auto format(format_string<T...> fmt, T&&... args) - -> std::string { - return vformat(fmt, fmt::make_format_args(args...)); -} - -/** Formats a string and writes the output to ``out``. */ -template <typename OutputIt, - FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, char>::value)> -auto vformat_to(OutputIt out, string_view fmt, format_args args) -> OutputIt { - auto&& buf = detail::get_buffer<char>(out); - detail::vformat_to(buf, fmt, args, {}); - return detail::get_iterator(buf, out); -} - -/** - \rst - Formats ``args`` according to specifications in ``fmt``, writes the result to - the output iterator ``out`` and returns the iterator past the end of the output - range. `format_to` does not append a terminating null character. - - **Example**:: - - auto out = std::vector<char>(); - fmt::format_to(std::back_inserter(out), "{}", 42); - \endrst - */ -template <typename OutputIt, typename... T, - FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, char>::value)> -FMT_INLINE auto format_to(OutputIt out, format_string<T...> fmt, T&&... args) - -> OutputIt { - return vformat_to(out, fmt, fmt::make_format_args(args...)); -} - -template <typename OutputIt> struct format_to_n_result { - /** Iterator past the end of the output range. */ - OutputIt out; - /** Total (not truncated) output size. */ - size_t size; -}; - -template <typename OutputIt, typename... T, - FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, char>::value)> -auto vformat_to_n(OutputIt out, size_t n, string_view fmt, format_args args) - -> format_to_n_result<OutputIt> { - using traits = detail::fixed_buffer_traits; - auto buf = detail::iterator_buffer<OutputIt, char, traits>(out, n); - detail::vformat_to(buf, fmt, args, {}); - return {buf.out(), buf.count()}; -} - -/** - \rst - Formats ``args`` according to specifications in ``fmt``, writes up to ``n`` - characters of the result to the output iterator ``out`` and returns the total - (not truncated) output size and the iterator past the end of the output range. - `format_to_n` does not append a terminating null character. - \endrst - */ -template <typename OutputIt, typename... T, - FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, char>::value)> -FMT_INLINE auto format_to_n(OutputIt out, size_t n, format_string<T...> fmt, - T&&... args) -> format_to_n_result<OutputIt> { - return vformat_to_n(out, n, fmt, fmt::make_format_args(args...)); -} - -/** Returns the number of chars in the output of ``format(fmt, args...)``. */ -template <typename... T> -FMT_NODISCARD FMT_INLINE auto formatted_size(format_string<T...> fmt, - T&&... args) -> size_t { - auto buf = detail::counting_buffer<>(); - detail::vformat_to<char>(buf, fmt, fmt::make_format_args(args...), {}); - return buf.count(); -} - -FMT_API void vprint(string_view fmt, format_args args); -FMT_API void vprint(std::FILE* f, string_view fmt, format_args args); - -/** - \rst - Formats ``args`` according to specifications in ``fmt`` and writes the output - to ``stdout``. - - **Example**:: - - fmt::print("Elapsed time: {0:.2f} seconds", 1.23); - \endrst - */ -template <typename... T> -FMT_INLINE void print(format_string<T...> fmt, T&&... args) { - const auto& vargs = fmt::make_format_args(args...); - return detail::is_utf8() ? vprint(fmt, vargs) - : detail::vprint_mojibake(stdout, fmt, vargs); -} - -/** - \rst - Formats ``args`` according to specifications in ``fmt`` and writes the - output to the file ``f``. - - **Example**:: - - fmt::print(stderr, "Don't {}!", "panic"); - \endrst - */ -template <typename... T> -FMT_INLINE void print(std::FILE* f, format_string<T...> fmt, T&&... args) { - const auto& vargs = fmt::make_format_args(args...); - return detail::is_utf8() ? vprint(f, fmt, vargs) - : detail::vprint_mojibake(f, fmt, vargs); -} - -/** - Formats ``args`` according to specifications in ``fmt`` and writes the - output to the file ``f`` followed by a newline. - */ -template <typename... T> -FMT_INLINE void println(std::FILE* f, format_string<T...> fmt, T&&... args) { - return fmt::print(f, "{}\n", fmt::format(fmt, std::forward<T>(args)...)); -} - -/** - Formats ``args`` according to specifications in ``fmt`` and writes the output - to ``stdout`` followed by a newline. - */ -template <typename... T> -FMT_INLINE void println(format_string<T...> fmt, T&&... args) { - return fmt::println(stdout, fmt, std::forward<T>(args)...); -} - -FMT_END_EXPORT -FMT_GCC_PRAGMA("GCC pop_options") -FMT_END_NAMESPACE - -#ifdef FMT_HEADER_ONLY -# include "format.h" -#endif -#endif // FMT_CORE_H_ +#include "format.h" diff --git a/contrib/fmt/include/fmt/format-inl.h b/contrib/fmt/include/fmt/format-inl.h index 5bae3c7b2..8d07cc672 100644 --- a/contrib/fmt/include/fmt/format-inl.h +++ b/contrib/fmt/include/fmt/format-inl.h @@ -8,17 +8,19 @@ #ifndef FMT_FORMAT_INL_H_ #define FMT_FORMAT_INL_H_ -#include <algorithm> -#include <cerrno> // errno -#include <climits> -#include <cmath> -#include <exception> - -#ifndef FMT_STATIC_THOUSANDS_SEPARATOR -# include <locale> +#ifndef FMT_MODULE +# include <algorithm> +# include <cerrno> // errno +# include <climits> +# include <cmath> +# include <exception> + +# if !defined(FMT_STATIC_THOUSANDS_SEPARATOR) +# include <locale> +# endif #endif -#ifdef _WIN32 +#if defined(_WIN32) && !defined(FMT_USE_WRITE_CONSOLE) # include <io.h> // _isatty #endif @@ -36,10 +38,6 @@ FMT_FUNC void assert_fail(const char* file, int line, const char* message) { std::terminate(); } -FMT_FUNC void throw_format_error(const char* message) { - FMT_THROW(format_error(message)); -} - FMT_FUNC void format_error_code(detail::buffer<char>& out, int error_code, string_view message) noexcept { // Report error code making sure that the output fits into @@ -56,10 +54,10 @@ FMT_FUNC void format_error_code(detail::buffer<char>& out, int error_code, ++error_code_size; } error_code_size += detail::to_unsigned(detail::count_digits(abs_value)); - auto it = buffer_appender<char>(out); + auto it = appender(out); if (message.size() <= inline_buffer_size - error_code_size) - format_to(it, FMT_STRING("{}{}"), message, SEP); - format_to(it, FMT_STRING("{}{}"), ERROR_STR, error_code); + fmt::format_to(it, FMT_STRING("{}{}"), message, SEP); + fmt::format_to(it, FMT_STRING("{}{}"), ERROR_STR, error_code); FMT_ASSERT(out.size() <= inline_buffer_size, ""); } @@ -73,9 +71,8 @@ FMT_FUNC void report_error(format_func func, int error_code, } // A wrapper around fwrite that throws on error. -inline void fwrite_fully(const void* ptr, size_t size, size_t count, - FILE* stream) { - size_t written = std::fwrite(ptr, size, count, stream); +inline void fwrite_fully(const void* ptr, size_t count, FILE* stream) { + size_t written = std::fwrite(ptr, 1, count, stream); if (written < count) FMT_THROW(system_error(errno, FMT_STRING("cannot write to file"))); } @@ -86,7 +83,7 @@ locale_ref::locale_ref(const Locale& loc) : locale_(&loc) { static_assert(std::is_same<Locale, std::locale>::value, ""); } -template <typename Locale> Locale locale_ref::get() const { +template <typename Locale> auto locale_ref::get() const -> Locale { static_assert(std::is_same<Locale, std::locale>::value, ""); return locale_ ? *static_cast<const std::locale*>(locale_) : std::locale(); } @@ -98,7 +95,8 @@ FMT_FUNC auto thousands_sep_impl(locale_ref loc) -> thousands_sep_result<Char> { auto thousands_sep = grouping.empty() ? Char() : facet.thousands_sep(); return {std::move(grouping), thousands_sep}; } -template <typename Char> FMT_FUNC Char decimal_point_impl(locale_ref loc) { +template <typename Char> +FMT_FUNC auto decimal_point_impl(locale_ref loc) -> Char { return std::use_facet<std::numpunct<Char>>(loc.get<std::locale>()) .decimal_point(); } @@ -113,8 +111,12 @@ template <typename Char> FMT_FUNC Char decimal_point_impl(locale_ref) { #endif FMT_FUNC auto write_loc(appender out, loc_value value, - const format_specs<>& specs, locale_ref loc) -> bool { -#ifndef FMT_STATIC_THOUSANDS_SEPARATOR + const format_specs& specs, locale_ref loc) -> bool { +#ifdef FMT_STATIC_THOUSANDS_SEPARATOR + value.visit(loc_writer<>{ + out, specs, std::string(1, FMT_STATIC_THOUSANDS_SEPARATOR), "\3", "."}); + return true; +#else auto locale = loc.get<std::locale>(); // We cannot use the num_put<char> facet because it may produce output in // a wrong encoding. @@ -123,10 +125,13 @@ FMT_FUNC auto write_loc(appender out, loc_value value, return std::use_facet<facet>(locale).put(out, value, specs); return facet(locale).put(out, value, specs); #endif - return false; } } // namespace detail +FMT_FUNC void report_error(const char* message) { + FMT_THROW(format_error(message)); +} + template <typename Locale> typename Locale::id format_facet<Locale>::id; #ifndef FMT_STATIC_THOUSANDS_SEPARATOR @@ -138,30 +143,31 @@ template <typename Locale> format_facet<Locale>::format_facet(Locale& loc) { template <> FMT_API FMT_FUNC auto format_facet<std::locale>::do_put( - appender out, loc_value val, const format_specs<>& specs) const -> bool { + appender out, loc_value val, const format_specs& specs) const -> bool { return val.visit( detail::loc_writer<>{out, specs, separator_, grouping_, decimal_point_}); } #endif -FMT_FUNC std::system_error vsystem_error(int error_code, string_view fmt, - format_args args) { +FMT_FUNC auto vsystem_error(int error_code, string_view fmt, format_args args) + -> std::system_error { auto ec = std::error_code(error_code, std::generic_category()); return std::system_error(ec, vformat(fmt, args)); } namespace detail { -template <typename F> inline bool operator==(basic_fp<F> x, basic_fp<F> y) { +template <typename F> +inline auto operator==(basic_fp<F> x, basic_fp<F> y) -> bool { return x.f == y.f && x.e == y.e; } // Compilers should be able to optimize this into the ror instruction. -FMT_CONSTEXPR inline uint32_t rotr(uint32_t n, uint32_t r) noexcept { +FMT_CONSTEXPR inline auto rotr(uint32_t n, uint32_t r) noexcept -> uint32_t { r &= 31; return (n >> r) | (n << (32 - r)); } -FMT_CONSTEXPR inline uint64_t rotr(uint64_t n, uint32_t r) noexcept { +FMT_CONSTEXPR inline auto rotr(uint64_t n, uint32_t r) noexcept -> uint64_t { r &= 63; return (n >> r) | (n << (64 - r)); } @@ -170,14 +176,14 @@ FMT_CONSTEXPR inline uint64_t rotr(uint64_t n, uint32_t r) noexcept { namespace dragonbox { // Computes upper 64 bits of multiplication of a 32-bit unsigned integer and a // 64-bit unsigned integer. -inline uint64_t umul96_upper64(uint32_t x, uint64_t y) noexcept { +inline auto umul96_upper64(uint32_t x, uint64_t y) noexcept -> uint64_t { return umul128_upper64(static_cast<uint64_t>(x) << 32, y); } // Computes lower 128 bits of multiplication of a 64-bit unsigned integer and a // 128-bit unsigned integer. -inline uint128_fallback umul192_lower128(uint64_t x, - uint128_fallback y) noexcept { +inline auto umul192_lower128(uint64_t x, uint128_fallback y) noexcept + -> uint128_fallback { uint64_t high = x * y.high(); uint128_fallback high_low = umul128(x, y.low()); return {high + high_low.high(), high_low.low()}; @@ -185,12 +191,12 @@ inline uint128_fallback umul192_lower128(uint64_t x, // Computes lower 64 bits of multiplication of a 32-bit unsigned integer and a // 64-bit unsigned integer. -inline uint64_t umul96_lower64(uint32_t x, uint64_t y) noexcept { +inline auto umul96_lower64(uint32_t x, uint64_t y) noexcept -> uint64_t { return x * y; } // Various fast log computations. -inline int floor_log10_pow2_minus_log10_4_over_3(int e) noexcept { +inline auto floor_log10_pow2_minus_log10_4_over_3(int e) noexcept -> int { FMT_ASSERT(e <= 2936 && e >= -2985, "too large exponent"); return (e * 631305 - 261663) >> 21; } @@ -204,7 +210,7 @@ FMT_INLINE_VARIABLE constexpr struct { // divisible by pow(10, N). // Precondition: n <= pow(10, N + 1). template <int N> -bool check_divisibility_and_divide_by_pow10(uint32_t& n) noexcept { +auto check_divisibility_and_divide_by_pow10(uint32_t& n) noexcept -> bool { // The numbers below are chosen such that: // 1. floor(n/d) = floor(nm / 2^k) where d=10 or d=100, // 2. nm mod 2^k < m if and only if n is divisible by d, @@ -229,7 +235,7 @@ bool check_divisibility_and_divide_by_pow10(uint32_t& n) noexcept { // Computes floor(n / pow(10, N)) for small n and N. // Precondition: n <= pow(10, N + 1). -template <int N> uint32_t small_division_by_pow10(uint32_t n) noexcept { +template <int N> auto small_division_by_pow10(uint32_t n) noexcept -> uint32_t { constexpr auto info = div_small_pow10_infos[N - 1]; FMT_ASSERT(n <= info.divisor * 10, "n is too large"); constexpr uint32_t magic_number = @@ -238,12 +244,12 @@ template <int N> uint32_t small_division_by_pow10(uint32_t n) noexcept { } // Computes floor(n / 10^(kappa + 1)) (float) -inline uint32_t divide_by_10_to_kappa_plus_1(uint32_t n) noexcept { +inline auto divide_by_10_to_kappa_plus_1(uint32_t n) noexcept -> uint32_t { // 1374389535 = ceil(2^37/100) return static_cast<uint32_t>((static_cast<uint64_t>(n) * 1374389535) >> 37); } // Computes floor(n / 10^(kappa + 1)) (double) -inline uint64_t divide_by_10_to_kappa_plus_1(uint64_t n) noexcept { +inline auto divide_by_10_to_kappa_plus_1(uint64_t n) noexcept -> uint64_t { // 2361183241434822607 = ceil(2^(64+7)/1000) return umul128_upper64(n, 2361183241434822607ull) >> 7; } @@ -255,7 +261,7 @@ template <> struct cache_accessor<float> { using carrier_uint = float_info<float>::carrier_uint; using cache_entry_type = uint64_t; - static uint64_t get_cached_power(int k) noexcept { + static auto get_cached_power(int k) noexcept -> uint64_t { FMT_ASSERT(k >= float_info<float>::min_k && k <= float_info<float>::max_k, "k is out of range"); static constexpr const uint64_t pow10_significands[] = { @@ -297,20 +303,23 @@ template <> struct cache_accessor<float> { bool is_integer; }; - static compute_mul_result compute_mul( - carrier_uint u, const cache_entry_type& cache) noexcept { + static auto compute_mul(carrier_uint u, + const cache_entry_type& cache) noexcept + -> compute_mul_result { auto r = umul96_upper64(u, cache); return {static_cast<carrier_uint>(r >> 32), static_cast<carrier_uint>(r) == 0}; } - static uint32_t compute_delta(const cache_entry_type& cache, - int beta) noexcept { + static auto compute_delta(const cache_entry_type& cache, int beta) noexcept + -> uint32_t { return static_cast<uint32_t>(cache >> (64 - 1 - beta)); } - static compute_mul_parity_result compute_mul_parity( - carrier_uint two_f, const cache_entry_type& cache, int beta) noexcept { + static auto compute_mul_parity(carrier_uint two_f, + const cache_entry_type& cache, + int beta) noexcept + -> compute_mul_parity_result { FMT_ASSERT(beta >= 1, ""); FMT_ASSERT(beta < 64, ""); @@ -319,22 +328,22 @@ template <> struct cache_accessor<float> { static_cast<uint32_t>(r >> (32 - beta)) == 0}; } - static carrier_uint compute_left_endpoint_for_shorter_interval_case( - const cache_entry_type& cache, int beta) noexcept { + static auto compute_left_endpoint_for_shorter_interval_case( + const cache_entry_type& cache, int beta) noexcept -> carrier_uint { return static_cast<carrier_uint>( (cache - (cache >> (num_significand_bits<float>() + 2))) >> (64 - num_significand_bits<float>() - 1 - beta)); } - static carrier_uint compute_right_endpoint_for_shorter_interval_case( - const cache_entry_type& cache, int beta) noexcept { + static auto compute_right_endpoint_for_shorter_interval_case( + const cache_entry_type& cache, int beta) noexcept -> carrier_uint { return static_cast<carrier_uint>( (cache + (cache >> (num_significand_bits<float>() + 1))) >> (64 - num_significand_bits<float>() - 1 - beta)); } - static carrier_uint compute_round_up_for_shorter_interval_case( - const cache_entry_type& cache, int beta) noexcept { + static auto compute_round_up_for_shorter_interval_case( + const cache_entry_type& cache, int beta) noexcept -> carrier_uint { return (static_cast<carrier_uint>( cache >> (64 - num_significand_bits<float>() - 2 - beta)) + 1) / @@ -346,7 +355,7 @@ template <> struct cache_accessor<double> { using carrier_uint = float_info<double>::carrier_uint; using cache_entry_type = uint128_fallback; - static uint128_fallback get_cached_power(int k) noexcept { + static auto get_cached_power(int k) noexcept -> uint128_fallback { FMT_ASSERT(k >= float_info<double>::min_k && k <= float_info<double>::max_k, "k is out of range"); @@ -985,8 +994,7 @@ template <> struct cache_accessor<double> { {0xe0accfa875af45a7, 0x93eb1b80a33b8606}, {0x8c6c01c9498d8b88, 0xbc72f130660533c4}, {0xaf87023b9bf0ee6a, 0xeb8fad7c7f8680b5}, - { 0xdb68c2ca82ed2a05, - 0xa67398db9f6820e2 } + {0xdb68c2ca82ed2a05, 0xa67398db9f6820e2}, #else {0xff77b1fcbebcdc4f, 0x25e8e89c13bb0f7b}, {0xce5d73ff402d98e3, 0xfb0a3d212dc81290}, @@ -1071,19 +1079,22 @@ template <> struct cache_accessor<double> { bool is_integer; }; - static compute_mul_result compute_mul( - carrier_uint u, const cache_entry_type& cache) noexcept { + static auto compute_mul(carrier_uint u, + const cache_entry_type& cache) noexcept + -> compute_mul_result { auto r = umul192_upper128(u, cache); return {r.high(), r.low() == 0}; } - static uint32_t compute_delta(cache_entry_type const& cache, - int beta) noexcept { + static auto compute_delta(cache_entry_type const& cache, int beta) noexcept + -> uint32_t { return static_cast<uint32_t>(cache.high() >> (64 - 1 - beta)); } - static compute_mul_parity_result compute_mul_parity( - carrier_uint two_f, const cache_entry_type& cache, int beta) noexcept { + static auto compute_mul_parity(carrier_uint two_f, + const cache_entry_type& cache, + int beta) noexcept + -> compute_mul_parity_result { FMT_ASSERT(beta >= 1, ""); FMT_ASSERT(beta < 64, ""); @@ -1092,35 +1103,35 @@ template <> struct cache_accessor<double> { ((r.high() << beta) | (r.low() >> (64 - beta))) == 0}; } - static carrier_uint compute_left_endpoint_for_shorter_interval_case( - const cache_entry_type& cache, int beta) noexcept { + static auto compute_left_endpoint_for_shorter_interval_case( + const cache_entry_type& cache, int beta) noexcept -> carrier_uint { return (cache.high() - (cache.high() >> (num_significand_bits<double>() + 2))) >> (64 - num_significand_bits<double>() - 1 - beta); } - static carrier_uint compute_right_endpoint_for_shorter_interval_case( - const cache_entry_type& cache, int beta) noexcept { + static auto compute_right_endpoint_for_shorter_interval_case( + const cache_entry_type& cache, int beta) noexcept -> carrier_uint { return (cache.high() + (cache.high() >> (num_significand_bits<double>() + 1))) >> (64 - num_significand_bits<double>() - 1 - beta); } - static carrier_uint compute_round_up_for_shorter_interval_case( - const cache_entry_type& cache, int beta) noexcept { + static auto compute_round_up_for_shorter_interval_case( + const cache_entry_type& cache, int beta) noexcept -> carrier_uint { return ((cache.high() >> (64 - num_significand_bits<double>() - 2 - beta)) + 1) / 2; } }; -FMT_FUNC uint128_fallback get_cached_power(int k) noexcept { +FMT_FUNC auto get_cached_power(int k) noexcept -> uint128_fallback { return cache_accessor<double>::get_cached_power(k); } // Various integer checks template <typename T> -bool is_left_endpoint_integer_shorter_interval(int exponent) noexcept { +auto is_left_endpoint_integer_shorter_interval(int exponent) noexcept -> bool { const int case_shorter_interval_left_endpoint_lower_threshold = 2; const int case_shorter_interval_left_endpoint_upper_threshold = 3; return exponent >= case_shorter_interval_left_endpoint_lower_threshold && @@ -1128,16 +1139,12 @@ bool is_left_endpoint_integer_shorter_interval(int exponent) noexcept { } // Remove trailing zeros from n and return the number of zeros removed (float) -FMT_INLINE int remove_trailing_zeros(uint32_t& n) noexcept { +FMT_INLINE int remove_trailing_zeros(uint32_t& n, int s = 0) noexcept { FMT_ASSERT(n != 0, ""); // Modular inverse of 5 (mod 2^32): (mod_inv_5 * 5) mod 2^32 = 1. - // See https://github.com/fmtlib/fmt/issues/3163 for more details. - const uint32_t mod_inv_5 = 0xcccccccd; - // Casts are needed to workaround a bug in MSVC 19.22 and older. - const uint32_t mod_inv_25 = - static_cast<uint32_t>(uint64_t(mod_inv_5) * mod_inv_5); + constexpr uint32_t mod_inv_5 = 0xcccccccd; + constexpr uint32_t mod_inv_25 = 0xc28f5c29; // = mod_inv_5 * mod_inv_5 - int s = 0; while (true) { auto q = rotr(n * mod_inv_25, 2); if (q > max_value<uint32_t>() / 100) break; @@ -1162,32 +1169,17 @@ FMT_INLINE int remove_trailing_zeros(uint64_t& n) noexcept { // Is n is divisible by 10^8? if ((nm.high() & ((1ull << (90 - 64)) - 1)) == 0 && nm.low() < magic_number) { - // If yes, work with the quotient. + // If yes, work with the quotient... auto n32 = static_cast<uint32_t>(nm.high() >> (90 - 64)); - - const uint32_t mod_inv_5 = 0xcccccccd; - const uint32_t mod_inv_25 = mod_inv_5 * mod_inv_5; - - int s = 8; - while (true) { - auto q = rotr(n32 * mod_inv_25, 2); - if (q > max_value<uint32_t>() / 100) break; - n32 = q; - s += 2; - } - auto q = rotr(n32 * mod_inv_5, 1); - if (q <= max_value<uint32_t>() / 10) { - n32 = q; - s |= 1; - } - + // ... and use the 32 bit variant of the function + int s = remove_trailing_zeros(n32, 8); n = n32; return s; } // If n is not divisible by 10^8, work with n itself. - const uint64_t mod_inv_5 = 0xcccccccccccccccd; - const uint64_t mod_inv_25 = mod_inv_5 * mod_inv_5; + constexpr uint64_t mod_inv_5 = 0xcccccccccccccccd; + constexpr uint64_t mod_inv_25 = 0x8f5c28f5c28f5c29; // mod_inv_5 * mod_inv_5 int s = 0; while (true) { @@ -1253,7 +1245,7 @@ FMT_INLINE decimal_fp<T> shorter_interval_case(int exponent) noexcept { return ret_value; } -template <typename T> decimal_fp<T> to_decimal(T x) noexcept { +template <typename T> auto to_decimal(T x) noexcept -> decimal_fp<T> { // Step 1: integer promotion & Schubfach multiplier calculation. using carrier_uint = typename float_info<T>::carrier_uint; @@ -1392,15 +1384,15 @@ template <> struct formatter<detail::bigint> { for (auto i = n.bigits_.size(); i > 0; --i) { auto value = n.bigits_[i - 1u]; if (first) { - out = format_to(out, FMT_STRING("{:x}"), value); + out = fmt::format_to(out, FMT_STRING("{:x}"), value); first = false; continue; } - out = format_to(out, FMT_STRING("{:08x}"), value); + out = fmt::format_to(out, FMT_STRING("{:08x}"), value); } if (n.exp_ > 0) - out = format_to(out, FMT_STRING("p{}"), - n.exp_ * detail::bigint::bigit_bits); + out = fmt::format_to(out, FMT_STRING("p{}"), + n.exp_ * detail::bigint::bigit_bits); return out; } }; @@ -1424,7 +1416,7 @@ FMT_FUNC void format_system_error(detail::buffer<char>& out, int error_code, const char* message) noexcept { FMT_TRY { auto ec = std::error_code(error_code, std::generic_category()); - write(std::back_inserter(out), std::system_error(ec, message).what()); + detail::write(appender(out), std::system_error(ec, message).what()); return; } FMT_CATCH(...) {} @@ -1436,7 +1428,7 @@ FMT_FUNC void report_system_error(int error_code, report_error(format_system_error, error_code, message); } -FMT_FUNC std::string vformat(string_view fmt, format_args args) { +FMT_FUNC auto vformat(string_view fmt, format_args args) -> std::string { // Don't optimize the "{}" case to keep the binary size small and because it // can be better optimized in fmt::format anyway. auto buffer = memory_buffer(); @@ -1445,39 +1437,270 @@ FMT_FUNC std::string vformat(string_view fmt, format_args args) { } namespace detail { -#ifndef _WIN32 -FMT_FUNC bool write_console(std::FILE*, string_view) { return false; } + +template <typename T> struct span { + T* data; + size_t size; +}; + +#ifdef _WIN32 +inline void flockfile(FILE* f) { _lock_file(f); } +inline void funlockfile(FILE* f) { _unlock_file(f); } +inline int getc_unlocked(FILE* f) { return _fgetc_nolock(f); } +#endif + +// A FILE wrapper. F is FILE defined as a template parameter to make system API +// detection work. +template <typename F> class file_base { + public: + F* file_; + + public: + file_base(F* file) : file_(file) {} + operator F*() const { return file_; } + + // Reads a code unit from the stream. + auto get() -> int { + int result = getc_unlocked(file_); + if (result == EOF && ferror(file_) != 0) + FMT_THROW(system_error(errno, FMT_STRING("getc failed"))); + return result; + } + + // Puts the code unit back into the stream buffer. + void unget(char c) { + if (ungetc(c, file_) == EOF) + FMT_THROW(system_error(errno, FMT_STRING("ungetc failed"))); + } + + void flush() { fflush(this->file_); } +}; + +// A FILE wrapper for glibc. +template <typename F> class glibc_file : public file_base<F> { + private: + enum { + line_buffered = 0x200, // _IO_LINE_BUF + unbuffered = 2 // _IO_UNBUFFERED + }; + + public: + using file_base<F>::file_base; + + auto is_buffered() const -> bool { + return (this->file_->_flags & unbuffered) == 0; + } + + void init_buffer() { + if (this->file_->_IO_write_ptr) return; + // Force buffer initialization by placing and removing a char in a buffer. + putc_unlocked(0, this->file_); + --this->file_->_IO_write_ptr; + } + + // Returns the file's read buffer. + auto get_read_buffer() const -> span<const char> { + auto ptr = this->file_->_IO_read_ptr; + return {ptr, to_unsigned(this->file_->_IO_read_end - ptr)}; + } + + // Returns the file's write buffer. + auto get_write_buffer() const -> span<char> { + auto ptr = this->file_->_IO_write_ptr; + return {ptr, to_unsigned(this->file_->_IO_buf_end - ptr)}; + } + + void advance_write_buffer(size_t size) { this->file_->_IO_write_ptr += size; } + + bool needs_flush() const { + if ((this->file_->_flags & line_buffered) == 0) return false; + char* end = this->file_->_IO_write_end; + return memchr(end, '\n', to_unsigned(this->file_->_IO_write_ptr - end)); + } + + void flush() { fflush_unlocked(this->file_); } +}; + +// A FILE wrapper for Apple's libc. +template <typename F> class apple_file : public file_base<F> { + private: + enum { + line_buffered = 1, // __SNBF + unbuffered = 2 // __SLBF + }; + + public: + using file_base<F>::file_base; + + auto is_buffered() const -> bool { + return (this->file_->_flags & unbuffered) == 0; + } + + void init_buffer() { + if (this->file_->_p) return; + // Force buffer initialization by placing and removing a char in a buffer. + putc_unlocked(0, this->file_); + --this->file_->_p; + ++this->file_->_w; + } + + auto get_read_buffer() const -> span<const char> { + return {reinterpret_cast<char*>(this->file_->_p), + to_unsigned(this->file_->_r)}; + } + + auto get_write_buffer() const -> span<char> { + return {reinterpret_cast<char*>(this->file_->_p), + to_unsigned(this->file_->_bf._base + this->file_->_bf._size - + this->file_->_p)}; + } + + void advance_write_buffer(size_t size) { + this->file_->_p += size; + this->file_->_w -= size; + } + + bool needs_flush() const { + if ((this->file_->_flags & line_buffered) == 0) return false; + return memchr(this->file_->_p + this->file_->_w, '\n', + to_unsigned(-this->file_->_w)); + } +}; + +// A fallback FILE wrapper. +template <typename F> class fallback_file : public file_base<F> { + private: + char next_; // The next unconsumed character in the buffer. + bool has_next_ = false; + + public: + using file_base<F>::file_base; + + auto is_buffered() const -> bool { return false; } + auto needs_flush() const -> bool { return false; } + void init_buffer() {} + + auto get_read_buffer() const -> span<const char> { + return {&next_, has_next_ ? 1u : 0u}; + } + + auto get_write_buffer() const -> span<char> { return {nullptr, 0}; } + + void advance_write_buffer(size_t) {} + + auto get() -> int { + has_next_ = false; + return file_base<F>::get(); + } + + void unget(char c) { + file_base<F>::unget(c); + next_ = c; + has_next_ = true; + } +}; + +#ifndef FMT_USE_FALLBACK_FILE +# define FMT_USE_FALLBACK_FILE 1 +#endif + +template <typename F, + FMT_ENABLE_IF(sizeof(F::_p) != 0 && !FMT_USE_FALLBACK_FILE)> +auto get_file(F* f, int) -> apple_file<F> { + return f; +} +template <typename F, + FMT_ENABLE_IF(sizeof(F::_IO_read_ptr) != 0 && !FMT_USE_FALLBACK_FILE)> +inline auto get_file(F* f, int) -> glibc_file<F> { + return f; +} + +inline auto get_file(FILE* f, ...) -> fallback_file<FILE> { return f; } + +using file_ref = decltype(get_file(static_cast<FILE*>(nullptr), 0)); + +class file_print_buffer : public buffer<char> { + private: + file_ref file_; + + static void grow(buffer<char>& base, size_t) { + auto& self = static_cast<file_print_buffer&>(base); + self.file_.advance_write_buffer(self.size()); + if (self.file_.get_write_buffer().size == 0) self.file_.flush(); + auto buf = self.file_.get_write_buffer(); + FMT_ASSERT(buf.size > 0, ""); + self.set(buf.data, buf.size); + self.clear(); + } + + public: + explicit file_print_buffer(FILE* f) : buffer(grow, size_t()), file_(f) { + flockfile(f); + file_.init_buffer(); + auto buf = file_.get_write_buffer(); + set(buf.data, buf.size); + } + ~file_print_buffer() { + file_.advance_write_buffer(size()); + bool flush = file_.needs_flush(); + funlockfile(file_); + if (flush) fflush(file_); + } +}; + +#if !defined(_WIN32) || defined(FMT_USE_WRITE_CONSOLE) +FMT_FUNC auto write_console(int, string_view) -> bool { return false; } #else using dword = conditional_t<sizeof(long) == 4, unsigned long, unsigned>; extern "C" __declspec(dllimport) int __stdcall WriteConsoleW( // void*, const void*, dword, dword*, void*); -FMT_FUNC bool write_console(std::FILE* f, string_view text) { - auto fd = _fileno(f); - if (!_isatty(fd)) return false; +FMT_FUNC bool write_console(int fd, string_view text) { auto u16 = utf8_to_utf16(text); - auto written = dword(); return WriteConsoleW(reinterpret_cast<void*>(_get_osfhandle(fd)), u16.c_str(), - static_cast<uint32_t>(u16.size()), &written, nullptr); + static_cast<dword>(u16.size()), nullptr, nullptr) != 0; } +#endif +#ifdef _WIN32 // Print assuming legacy (non-Unicode) encoding. -FMT_FUNC void vprint_mojibake(std::FILE* f, string_view fmt, format_args args) { +FMT_FUNC void vprint_mojibake(std::FILE* f, string_view fmt, format_args args, + bool newline) { auto buffer = memory_buffer(); - detail::vformat_to(buffer, fmt, - basic_format_args<buffer_context<char>>(args)); - fwrite_fully(buffer.data(), 1, buffer.size(), f); + detail::vformat_to(buffer, fmt, args); + if (newline) buffer.push_back('\n'); + fwrite_fully(buffer.data(), buffer.size(), f); } #endif FMT_FUNC void print(std::FILE* f, string_view text) { - if (!write_console(f, text)) fwrite_fully(text.data(), 1, text.size(), f); +#if defined(_WIN32) && !defined(FMT_USE_WRITE_CONSOLE) + int fd = _fileno(f); + if (_isatty(fd)) { + std::fflush(f); + if (write_console(fd, text)) return; + } +#endif + fwrite_fully(text.data(), text.size(), f); } } // namespace detail +FMT_FUNC void vprint_buffered(std::FILE* f, string_view fmt, format_args args) { + auto buffer = memory_buffer(); + detail::vformat_to(buffer, fmt, args); + detail::print(f, {buffer.data(), buffer.size()}); +} + FMT_FUNC void vprint(std::FILE* f, string_view fmt, format_args args) { + if (!detail::file_ref(f).is_buffered()) return vprint_buffered(f, fmt, args); + auto&& buffer = detail::file_print_buffer(f); + return detail::vformat_to(buffer, fmt, args); +} + +FMT_FUNC void vprintln(std::FILE* f, string_view fmt, format_args args) { auto buffer = memory_buffer(); detail::vformat_to(buffer, fmt, args); + buffer.push_back('\n'); detail::print(f, {buffer.data(), buffer.size()}); } diff --git a/contrib/fmt/include/fmt/format.h b/contrib/fmt/include/fmt/format.h index ed8b29eba..7c2a19b40 100644 --- a/contrib/fmt/include/fmt/format.h +++ b/contrib/fmt/include/fmt/format.h @@ -33,61 +33,65 @@ #ifndef FMT_FORMAT_H_ #define FMT_FORMAT_H_ -#include <cmath> // std::signbit -#include <cstdint> // uint32_t -#include <cstring> // std::memcpy -#include <initializer_list> // std::initializer_list -#include <limits> // std::numeric_limits -#include <memory> // std::uninitialized_copy -#include <stdexcept> // std::runtime_error -#include <system_error> // std::system_error - -#ifdef __cpp_lib_bit_cast -# include <bit> // std::bitcast +#ifndef _LIBCPP_REMOVE_TRANSITIVE_INCLUDES +# define _LIBCPP_REMOVE_TRANSITIVE_INCLUDES +# define FMT_REMOVE_TRANSITIVE_INCLUDES #endif -#include "core.h" +#include "base.h" + +#ifndef FMT_MODULE +# include <cmath> // std::signbit +# include <cstdint> // uint32_t +# include <cstring> // std::memcpy +# include <initializer_list> // std::initializer_list +# include <limits> // std::numeric_limits +# if defined(__GLIBCXX__) && !defined(_GLIBCXX_USE_DUAL_ABI) +// Workaround for pre gcc 5 libstdc++. +# include <memory> // std::allocator_traits +# endif +# include <stdexcept> // std::runtime_error +# include <string> // std::string +# include <system_error> // std::system_error -#ifndef FMT_BEGIN_DETAIL_NAMESPACE -# define FMT_BEGIN_DETAIL_NAMESPACE namespace detail { -# define FMT_END_DETAIL_NAMESPACE } -#endif +// Checking FMT_CPLUSPLUS for warning suppression in MSVC. +# if FMT_HAS_INCLUDE(<bit>) && FMT_CPLUSPLUS > 201703L +# include <bit> // std::bit_cast +# endif + +// libc++ supports string_view in pre-c++17. +# if FMT_HAS_INCLUDE(<string_view>) && \ + (FMT_CPLUSPLUS >= 201703L || defined(_LIBCPP_VERSION)) +# include <string_view> +# define FMT_USE_STRING_VIEW +# endif +#endif // FMT_MODULE -#if FMT_HAS_CPP17_ATTRIBUTE(fallthrough) -# define FMT_FALLTHROUGH [[fallthrough]] -#elif defined(__clang__) -# define FMT_FALLTHROUGH [[clang::fallthrough]] -#elif FMT_GCC_VERSION >= 700 && \ - (!defined(__EDG_VERSION__) || __EDG_VERSION__ >= 520) -# define FMT_FALLTHROUGH [[gnu::fallthrough]] +#if defined __cpp_inline_variables && __cpp_inline_variables >= 201606L +# define FMT_INLINE_VARIABLE inline #else -# define FMT_FALLTHROUGH +# define FMT_INLINE_VARIABLE #endif -#ifndef FMT_DEPRECATED -# if FMT_HAS_CPP14_ATTRIBUTE(deprecated) || FMT_MSC_VERSION >= 1900 -# define FMT_DEPRECATED [[deprecated]] -# else -# if (defined(__GNUC__) && !defined(__LCC__)) || defined(__clang__) -# define FMT_DEPRECATED __attribute__((deprecated)) -# elif FMT_MSC_VERSION -# define FMT_DEPRECATED __declspec(deprecated) -# else -# define FMT_DEPRECATED /* deprecated */ +#ifndef FMT_NO_UNIQUE_ADDRESS +# if FMT_CPLUSPLUS >= 202002L +# if FMT_HAS_CPP_ATTRIBUTE(no_unique_address) +# define FMT_NO_UNIQUE_ADDRESS [[no_unique_address]] +// VS2019 v16.10 and later except clang-cl (https://reviews.llvm.org/D110485). +# elif (FMT_MSC_VERSION >= 1929) && !FMT_CLANG_VERSION +# define FMT_NO_UNIQUE_ADDRESS [[msvc::no_unique_address]] # endif # endif #endif - -#if FMT_GCC_VERSION -# define FMT_GCC_VISIBILITY_HIDDEN __attribute__((visibility("hidden"))) -#else -# define FMT_GCC_VISIBILITY_HIDDEN +#ifndef FMT_NO_UNIQUE_ADDRESS +# define FMT_NO_UNIQUE_ADDRESS #endif -#ifdef __NVCC__ -# define FMT_CUDA_VERSION (__CUDACC_VER_MAJOR__ * 100 + __CUDACC_VER_MINOR__) +// Visibility when compiled as a shared library/object. +#if defined(FMT_LIB_EXPORT) || defined(FMT_SHARED) +# define FMT_SO_VISIBILITY(value) FMT_VISIBILITY(value) #else -# define FMT_CUDA_VERSION 0 +# define FMT_SO_VISIBILITY(value) #endif #ifdef __has_builtin @@ -120,21 +124,11 @@ FMT_END_NAMESPACE # define FMT_THROW(x) throw x # endif # else -# define FMT_THROW(x) \ - do { \ - FMT_ASSERT(false, (x).what()); \ - } while (false) +# define FMT_THROW(x) \ + ::fmt::detail::assert_fail(__FILE__, __LINE__, (x).what()) # endif #endif -#if FMT_EXCEPTIONS -# define FMT_TRY try -# define FMT_CATCH(x) catch (x) -#else -# define FMT_TRY if (true) -# define FMT_CATCH(x) if (false) -#endif - #ifndef FMT_MAYBE_UNUSED # if FMT_HAS_CPP17_ATTRIBUTE(maybe_unused) # define FMT_MAYBE_UNUSED [[maybe_unused]] @@ -145,7 +139,10 @@ FMT_END_NAMESPACE #ifndef FMT_USE_USER_DEFINED_LITERALS // EDG based compilers (Intel, NVIDIA, Elbrus, etc), GCC and MSVC support UDLs. -# if (FMT_HAS_FEATURE(cxx_user_literals) || FMT_GCC_VERSION >= 407 || \ +// +// GCC before 4.9 requires a space in `operator"" _a` which is invalid in later +// compiler versions. +# if (FMT_HAS_FEATURE(cxx_user_literals) || FMT_GCC_VERSION >= 409 || \ FMT_MSC_VERSION >= 1900) && \ (!defined(__EDG_VERSION__) || __EDG_VERSION__ >= /* UDL feature */ 480) # define FMT_USE_USER_DEFINED_LITERALS 1 @@ -267,17 +264,9 @@ FMT_END_NAMESPACE FMT_BEGIN_NAMESPACE -template <typename...> struct disjunction : std::false_type {}; -template <typename P> struct disjunction<P> : P {}; -template <typename P1, typename... Pn> -struct disjunction<P1, Pn...> - : conditional_t<bool(P1::value), P1, disjunction<Pn...>> {}; - -template <typename...> struct conjunction : std::true_type {}; -template <typename P> struct conjunction<P> : P {}; -template <typename P1, typename... Pn> -struct conjunction<P1, Pn...> - : conditional_t<bool(P1::value), conjunction<Pn...>, P1> {}; +template <typename Char, typename Traits, typename Allocator> +struct is_contiguous<std::basic_string<Char, Traits, Allocator>> + : std::true_type {}; namespace detail { @@ -288,49 +277,12 @@ FMT_CONSTEXPR inline void abort_fuzzing_if(bool condition) { #endif } -template <typename CharT, CharT... C> struct string_literal { - static constexpr CharT value[sizeof...(C)] = {C...}; - constexpr operator basic_string_view<CharT>() const { - return {value, sizeof...(C)}; - } -}; - -#if FMT_CPLUSPLUS < 201703L -template <typename CharT, CharT... C> -constexpr CharT string_literal<CharT, C...>::value[sizeof...(C)]; +#if defined(FMT_USE_STRING_VIEW) +template <typename Char> using std_string_view = std::basic_string_view<Char>; +#else +template <typename T> struct std_string_view {}; #endif -template <typename Streambuf> class formatbuf : public Streambuf { - private: - using char_type = typename Streambuf::char_type; - using streamsize = decltype(std::declval<Streambuf>().sputn(nullptr, 0)); - using int_type = typename Streambuf::int_type; - using traits_type = typename Streambuf::traits_type; - - buffer<char_type>& buffer_; - - public: - explicit formatbuf(buffer<char_type>& buf) : buffer_(buf) {} - - protected: - // The put area is always empty. This makes the implementation simpler and has - // the advantage that the streambuf and the buffer are always in sync and - // sputc never writes into uninitialized memory. A disadvantage is that each - // call to sputc always results in a (virtual) call to overflow. There is no - // disadvantage here for sputn since this always results in a call to xsputn. - - auto overflow(int_type ch) -> int_type override { - if (!traits_type::eq_int_type(ch, traits_type::eof())) - buffer_.push_back(static_cast<char_type>(ch)); - return ch; - } - - auto xsputn(const char_type* s, streamsize count) -> streamsize override { - buffer_.append(s, s + count); - return count; - } -}; - // Implementation of std::bit_cast for pre-C++20. template <typename To, typename From, FMT_ENABLE_IF(sizeof(To) == sizeof(From))> FMT_CONSTEXPR20 auto bit_cast(const From& from) -> To { @@ -362,14 +314,12 @@ class uint128_fallback { private: uint64_t lo_, hi_; - friend uint128_fallback umul128(uint64_t x, uint64_t y) noexcept; - public: constexpr uint128_fallback(uint64_t hi, uint64_t lo) : lo_(lo), hi_(hi) {} constexpr uint128_fallback(uint64_t value = 0) : lo_(value), hi_(0) {} - constexpr uint64_t high() const noexcept { return hi_; } - constexpr uint64_t low() const noexcept { return lo_; } + constexpr auto high() const noexcept -> uint64_t { return hi_; } + constexpr auto low() const noexcept -> uint64_t { return lo_; } template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)> constexpr explicit operator T() const { @@ -445,7 +395,7 @@ class uint128_fallback { hi_ &= n.hi_; } - FMT_CONSTEXPR20 uint128_fallback& operator+=(uint64_t n) noexcept { + FMT_CONSTEXPR20 auto operator+=(uint64_t n) noexcept -> uint128_fallback& { if (is_constant_evaluated()) { lo_ += n; hi_ += (lo_ < n ? 1 : 0); @@ -489,7 +439,8 @@ template <typename T> constexpr auto num_bits() -> int { } // std::numeric_limits<T>::digits may return 0 for 128-bit ints. template <> constexpr auto num_bits<int128_opt>() -> int { return 128; } -template <> constexpr auto num_bits<uint128_t>() -> int { return 128; } +template <> constexpr auto num_bits<uint128_opt>() -> int { return 128; } +template <> constexpr auto num_bits<uint128_fallback>() -> int { return 128; } // A heterogeneous bit_cast used for converting 96-bit long double to uint128_t // and 128-bit pointers to uint128_fallback. @@ -536,6 +487,8 @@ FMT_INLINE void assume(bool condition) { (void)condition; #if FMT_HAS_BUILTIN(__builtin_assume) && !FMT_ICC_VERSION __builtin_assume(condition); +#elif FMT_GCC_VERSION + if (!condition) __builtin_unreachable(); #endif } @@ -554,37 +507,24 @@ inline auto get_data(Container& c) -> typename Container::value_type* { return c.data(); } -#if defined(_SECURE_SCL) && _SECURE_SCL -// Make a checked iterator to avoid MSVC warnings. -template <typename T> using checked_ptr = stdext::checked_array_iterator<T*>; -template <typename T> -constexpr auto make_checked(T* p, size_t size) -> checked_ptr<T> { - return {p, size}; -} -#else -template <typename T> using checked_ptr = T*; -template <typename T> constexpr auto make_checked(T* p, size_t) -> T* { - return p; -} -#endif - // Attempts to reserve space for n extra characters in the output range. // Returns a pointer to the reserved range or a reference to it. -template <typename Container, FMT_ENABLE_IF(is_contiguous<Container>::value)> +template <typename OutputIt, + FMT_ENABLE_IF(is_back_insert_iterator<OutputIt>::value&& + is_contiguous<typename OutputIt::container>::value)> #if FMT_CLANG_VERSION >= 307 && !FMT_ICC_VERSION __attribute__((no_sanitize("undefined"))) #endif inline auto -reserve(std::back_insert_iterator<Container> it, size_t n) - -> checked_ptr<typename Container::value_type> { - Container& c = get_container(it); +reserve(OutputIt it, size_t n) -> typename OutputIt::value_type* { + auto& c = get_container(it); size_t size = c.size(); c.resize(size + n); - return make_checked(get_data(c) + size, n); + return get_data(c) + size; } template <typename T> -inline auto reserve(buffer_appender<T> it, size_t n) -> buffer_appender<T> { +inline auto reserve(basic_appender<T> it, size_t n) -> basic_appender<T> { buffer<T>& buf = get_container(it); buf.try_reserve(buf.size() + n); return it; @@ -603,7 +543,7 @@ template <typename T, typename OutputIt> constexpr auto to_pointer(OutputIt, size_t) -> T* { return nullptr; } -template <typename T> auto to_pointer(buffer_appender<T> it, size_t n) -> T* { +template <typename T> auto to_pointer(basic_appender<T> it, size_t n) -> T* { buffer<T>& buf = get_container(it); auto size = buf.size(); if (buf.capacity() < size + n) return nullptr; @@ -611,10 +551,12 @@ template <typename T> auto to_pointer(buffer_appender<T> it, size_t n) -> T* { return buf.data() + size; } -template <typename Container, FMT_ENABLE_IF(is_contiguous<Container>::value)> -inline auto base_iterator(std::back_insert_iterator<Container>& it, - checked_ptr<typename Container::value_type>) - -> std::back_insert_iterator<Container> { +template <typename OutputIt, + FMT_ENABLE_IF(is_back_insert_iterator<OutputIt>::value&& + is_contiguous<typename OutputIt::container>::value)> +inline auto base_iterator(OutputIt it, + typename OutputIt::container_type::value_type*) + -> OutputIt { return it; } @@ -640,16 +582,10 @@ FMT_CONSTEXPR20 auto fill_n(T* out, Size count, char value) -> T* { return out + count; } -#ifdef __cpp_char8_t -using char8_type = char8_t; -#else -enum char8_type : unsigned char {}; -#endif - template <typename OutChar, typename InputIt, typename OutputIt> -FMT_CONSTEXPR FMT_NOINLINE auto copy_str_noinline(InputIt begin, InputIt end, - OutputIt out) -> OutputIt { - return copy_str<OutChar>(begin, end, out); +FMT_CONSTEXPR FMT_NOINLINE auto copy_noinline(InputIt begin, InputIt end, + OutputIt out) -> OutputIt { + return copy<OutChar>(begin, end, out); } // A public domain branchless UTF-8 decoder by Christopher Wellons: @@ -730,7 +666,7 @@ FMT_CONSTEXPR void for_each_codepoint(string_view s, F f) { } if (auto num_chars_left = s.data() + s.size() - p) { char buf[2 * block_size - 1] = {}; - copy_str<char>(p, p + num_chars_left, buf); + copy<char>(p, p + num_chars_left, buf); const char* buf_ptr = buf; do { auto end = decode(buf_ptr, p); @@ -747,7 +683,7 @@ inline auto compute_width(basic_string_view<Char> s) -> size_t { } // Computes approximate display width of a UTF-8 string. -FMT_CONSTEXPR inline size_t compute_width(string_view s) { +FMT_CONSTEXPR inline auto compute_width(string_view s) -> size_t { size_t num_code_points = 0; // It is not a lambda for compatibility with C++14. struct count_code_points { @@ -781,11 +717,6 @@ FMT_CONSTEXPR inline size_t compute_width(string_view s) { return num_code_points; } -inline auto compute_width(basic_string_view<char8_type> s) -> size_t { - return compute_width( - string_view(reinterpret_cast<const char*>(s.data()), s.size())); -} - template <typename Char> inline auto code_point_index(basic_string_view<Char> s, size_t n) -> size_t { size_t size = s.size(); @@ -794,18 +725,17 @@ inline auto code_point_index(basic_string_view<Char> s, size_t n) -> size_t { // Calculates the index of the nth code point in a UTF-8 string. inline auto code_point_index(string_view s, size_t n) -> size_t { - const char* data = s.data(); - size_t num_code_points = 0; - for (size_t i = 0, size = s.size(); i != size; ++i) { - if ((data[i] & 0xc0) != 0x80 && ++num_code_points > n) return i; - } - return s.size(); -} - -inline auto code_point_index(basic_string_view<char8_type> s, size_t n) - -> size_t { - return code_point_index( - string_view(reinterpret_cast<const char*>(s.data()), s.size()), n); + size_t result = s.size(); + const char* begin = s.begin(); + for_each_codepoint(s, [begin, &n, &result](uint32_t, string_view sv) { + if (n != 0) { + --n; + return true; + } + result = to_unsigned(sv.begin() - begin); + return false; + }); + return result; } template <typename T> struct is_integral : std::is_integral<T> {}; @@ -833,28 +763,22 @@ using is_integer = # define FMT_USE_LONG_DOUBLE 1 #endif -#ifndef FMT_USE_FLOAT128 -# ifdef __clang__ -// Clang emulates GCC, so it has to appear early. -# if FMT_HAS_INCLUDE(<quadmath.h>) -# define FMT_USE_FLOAT128 1 -# endif -# elif defined(__GNUC__) -// GNU C++: -# if defined(_GLIBCXX_USE_FLOAT128) && !defined(__STRICT_ANSI__) -# define FMT_USE_FLOAT128 1 -# endif -# endif -# ifndef FMT_USE_FLOAT128 -# define FMT_USE_FLOAT128 0 -# endif +#if defined(FMT_USE_FLOAT128) +// Use the provided definition. +#elif FMT_CLANG_VERSION && FMT_HAS_INCLUDE(<quadmath.h>) +# define FMT_USE_FLOAT128 1 +#elif FMT_GCC_VERSION && defined(_GLIBCXX_USE_FLOAT128) && \ + !defined(__STRICT_ANSI__) +# define FMT_USE_FLOAT128 1 +#else +# define FMT_USE_FLOAT128 0 #endif - #if FMT_USE_FLOAT128 using float128 = __float128; #else using float128 = void; #endif + template <typename T> using is_float128 = std::is_same<T, float128>; template <typename T> @@ -873,20 +797,6 @@ using is_double_double = bool_constant<std::numeric_limits<T>::digits == 106>; # define FMT_USE_FULL_CACHE_DRAGONBOX 0 #endif -template <typename T> -template <typename U> -void buffer<T>::append(const U* begin, const U* end) { - while (begin != end) { - auto count = to_unsigned(end - begin); - try_reserve(size_ + count); - auto free_cap = capacity_ - size_; - if (free_cap < count) count = free_cap; - std::uninitialized_copy_n(begin, count, make_checked(ptr_ + size_, count)); - size_ += count; - begin += count; - } -} - template <typename T, typename Enable = void> struct is_locale : std::false_type {}; template <typename T> @@ -900,34 +810,26 @@ FMT_BEGIN_EXPORT enum { inline_buffer_size = 500 }; /** - \rst - A dynamically growing memory buffer for trivially copyable/constructible types - with the first ``SIZE`` elements stored in the object itself. - - You can use the ``memory_buffer`` type alias for ``char`` instead. - - **Example**:: - - auto out = fmt::memory_buffer(); - format_to(std::back_inserter(out), "The answer is {}.", 42); - - This will append the following output to the ``out`` object: - - .. code-block:: none - - The answer is 42. - - The output can be converted to an ``std::string`` with ``to_string(out)``. - \endrst + * A dynamically growing memory buffer for trivially copyable/constructible + * types with the first `SIZE` elements stored in the object itself. Most + * commonly used via the `memory_buffer` alias for `char`. + * + * **Example**: + * + * auto out = fmt::memory_buffer(); + * fmt::format_to(std::back_inserter(out), "The answer is {}.", 42); + * + * This will append "The answer is 42." to `out`. The buffer content can be + * converted to `std::string` with `to_string(out)`. */ template <typename T, size_t SIZE = inline_buffer_size, typename Allocator = std::allocator<T>> -class basic_memory_buffer final : public detail::buffer<T> { +class basic_memory_buffer : public detail::buffer<T> { private: T store_[SIZE]; - // Don't inherit from Allocator avoid generating type_info for it. - Allocator alloc_; + // Don't inherit from Allocator to avoid generating type_info for it. + FMT_NO_UNIQUE_ADDRESS Allocator alloc_; // Deallocate memory allocated by the buffer. FMT_CONSTEXPR20 void deallocate() { @@ -935,27 +837,28 @@ class basic_memory_buffer final : public detail::buffer<T> { if (data != store_) alloc_.deallocate(data, this->capacity()); } - protected: - FMT_CONSTEXPR20 void grow(size_t size) override { + static FMT_CONSTEXPR20 void grow(detail::buffer<T>& buf, size_t size) { detail::abort_fuzzing_if(size > 5000); - const size_t max_size = std::allocator_traits<Allocator>::max_size(alloc_); - size_t old_capacity = this->capacity(); + auto& self = static_cast<basic_memory_buffer&>(buf); + const size_t max_size = + std::allocator_traits<Allocator>::max_size(self.alloc_); + size_t old_capacity = buf.capacity(); size_t new_capacity = old_capacity + old_capacity / 2; if (size > new_capacity) new_capacity = size; else if (new_capacity > max_size) new_capacity = size > max_size ? size : max_size; - T* old_data = this->data(); - T* new_data = - std::allocator_traits<Allocator>::allocate(alloc_, new_capacity); + T* old_data = buf.data(); + T* new_data = self.alloc_.allocate(new_capacity); + // Suppress a bogus -Wstringop-overflow in gcc 13.1 (#3481). + detail::assume(buf.size() <= new_capacity); // The following code doesn't throw, so the raw pointer above doesn't leak. - std::uninitialized_copy(old_data, old_data + this->size(), - detail::make_checked(new_data, new_capacity)); - this->set(new_data, new_capacity); + memcpy(new_data, old_data, buf.size() * sizeof(T)); + self.set(new_data, new_capacity); // deallocate must not throw according to the standard, but even if it does, // the buffer already uses the new storage and will deallocate it in // destructor. - if (old_data != store_) alloc_.deallocate(old_data, old_capacity); + if (old_data != self.store_) self.alloc_.deallocate(old_data, old_capacity); } public: @@ -964,7 +867,7 @@ class basic_memory_buffer final : public detail::buffer<T> { FMT_CONSTEXPR20 explicit basic_memory_buffer( const Allocator& alloc = Allocator()) - : alloc_(alloc) { + : detail::buffer<T>(grow), alloc_(alloc) { this->set(store_, SIZE); if (detail::is_constant_evaluated()) detail::fill_n(store_, SIZE, T()); } @@ -978,8 +881,7 @@ class basic_memory_buffer final : public detail::buffer<T> { size_t size = other.size(), capacity = other.capacity(); if (data == other.store_) { this->set(store_, capacity); - detail::copy_str<T>(other.store_, other.store_ + size, - detail::make_checked(store_, capacity)); + detail::copy<T>(other.store_, other.store_ + size, store_); } else { this->set(data, capacity); // Set pointer to the inline array so that delete is not called @@ -991,21 +893,14 @@ class basic_memory_buffer final : public detail::buffer<T> { } public: - /** - \rst - Constructs a :class:`fmt::basic_memory_buffer` object moving the content - of the other object to it. - \endrst - */ - FMT_CONSTEXPR20 basic_memory_buffer(basic_memory_buffer&& other) noexcept { + /// Constructs a `basic_memory_buffer` object moving the content of the other + /// object to it. + FMT_CONSTEXPR20 basic_memory_buffer(basic_memory_buffer&& other) noexcept + : detail::buffer<T>(grow) { move(other); } - /** - \rst - Moves the content of the other ``basic_memory_buffer`` object to this one. - \endrst - */ + /// Moves the content of the other `basic_memory_buffer` object to this one. auto operator=(basic_memory_buffer&& other) noexcept -> basic_memory_buffer& { FMT_ASSERT(this != &other, ""); deallocate(); @@ -1016,16 +911,13 @@ class basic_memory_buffer final : public detail::buffer<T> { // Returns a copy of the allocator associated with this buffer. auto get_allocator() const -> Allocator { return alloc_; } - /** - Resizes the buffer to contain *count* elements. If T is a POD type new - elements may not be initialized. - */ + /// Resizes the buffer to contain `count` elements. If T is a POD type new + /// elements may not be initialized. FMT_CONSTEXPR20 void resize(size_t count) { this->try_resize(count); } - /** Increases the buffer capacity to *new_capacity*. */ + /// Increases the buffer capacity to `new_capacity`. void reserve(size_t new_capacity) { this->try_reserve(new_capacity); } - // Directly append data into the buffer using detail::buffer<T>::append; template <typename ContiguousRange> void append(const ContiguousRange& range) { @@ -1041,9 +933,10 @@ struct is_contiguous<basic_memory_buffer<T, SIZE, Allocator>> : std::true_type { FMT_END_EXPORT namespace detail { -FMT_API bool write_console(std::FILE* f, string_view text); +FMT_API auto write_console(int fd, string_view text) -> bool; FMT_API void print(std::FILE*, string_view); } // namespace detail + FMT_BEGIN_EXPORT // Suppress a misleading warning in older versions of clang. @@ -1051,8 +944,8 @@ FMT_BEGIN_EXPORT # pragma clang diagnostic ignored "-Wweak-vtables" #endif -/** An error reported from a formatting function. */ -class FMT_API format_error : public std::runtime_error { +/// An error reported from a formatting function. +class FMT_SO_VISIBILITY("default") format_error : public std::runtime_error { public: using std::runtime_error::runtime_error; }; @@ -1061,8 +954,8 @@ namespace detail_exported { #if FMT_USE_NONTYPE_TEMPLATE_ARGS template <typename Char, size_t N> struct fixed_string { constexpr fixed_string(const Char (&str)[N]) { - detail::copy_str<Char, const Char*, Char*>(static_cast<const Char*>(str), - str + N, data); + detail::copy<Char, const Char*, Char*>(static_cast<const Char*>(str), + str + N, data); } Char data[N] = {}; }; @@ -1077,12 +970,57 @@ constexpr auto compile_string_to_view(const Char (&s)[N]) return {s, N - (std::char_traits<Char>::to_int_type(s[N - 1]) == 0 ? 1 : 0)}; } template <typename Char> -constexpr auto compile_string_to_view(detail::std_string_view<Char> s) +constexpr auto compile_string_to_view(basic_string_view<Char> s) -> basic_string_view<Char> { - return {s.data(), s.size()}; + return s; } } // namespace detail_exported +// A generic formatting context with custom output iterator and character +// (code unit) support. Char is the format string code unit type which can be +// different from OutputIt::value_type. +template <typename OutputIt, typename Char> class generic_context { + private: + OutputIt out_; + basic_format_args<generic_context> args_; + detail::locale_ref loc_; + + public: + using char_type = Char; + using iterator = OutputIt; + using parse_context_type = basic_format_parse_context<Char>; + template <typename T> using formatter_type = formatter<T, Char>; + + constexpr generic_context(OutputIt out, + basic_format_args<generic_context> ctx_args, + detail::locale_ref loc = {}) + : out_(out), args_(ctx_args), loc_(loc) {} + generic_context(generic_context&&) = default; + generic_context(const generic_context&) = delete; + void operator=(const generic_context&) = delete; + + constexpr auto arg(int id) const -> basic_format_arg<generic_context> { + return args_.get(id); + } + auto arg(basic_string_view<Char> name) -> basic_format_arg<generic_context> { + return args_.get(name); + } + FMT_CONSTEXPR auto arg_id(basic_string_view<Char> name) -> int { + return args_.get_id(name); + } + auto args() const -> const basic_format_args<generic_context>& { + return args_; + } + + FMT_CONSTEXPR auto out() -> iterator { return out_; } + + void advance_to(iterator it) { + if (!detail::is_back_insert_iterator<iterator>()) out_ = it; + } + + FMT_CONSTEXPR auto locale() -> detail::locale_ref { return loc_; } +}; + class loc_value { private: basic_format_arg<format_context> value_; @@ -1095,7 +1033,7 @@ class loc_value { loc_value(T) {} template <typename Visitor> auto visit(Visitor&& vis) -> decltype(vis(0)) { - return visit_format_arg(vis, value_); + return value_.visit(vis); } }; @@ -1109,7 +1047,7 @@ template <typename Locale> class format_facet : public Locale::facet { protected: virtual auto do_put(appender out, loc_value val, - const format_specs<>& specs) const -> bool; + const format_specs& specs) const -> bool; public: static FMT_API typename Locale::id id; @@ -1122,13 +1060,15 @@ template <typename Locale> class format_facet : public Locale::facet { grouping_(g.begin(), g.end()), decimal_point_(decimal_point) {} - auto put(appender out, loc_value val, const format_specs<>& specs) const + auto put(appender out, loc_value val, const format_specs& specs) const -> bool { return do_put(out, val, specs); } }; -FMT_BEGIN_DETAIL_NAMESPACE +FMT_END_EXPORT + +namespace detail { // Returns true if value is negative, false otherwise. // Same as `value < 0` but doesn't produce warnings if T is an unsigned type. @@ -1159,13 +1099,13 @@ using uint32_or_64_or_128_t = template <typename T> using uint64_or_128_t = conditional_t<num_bits<T>() <= 64, uint64_t, uint128_t>; -#define FMT_POWERS_OF_10(factor) \ - factor * 10, (factor)*100, (factor)*1000, (factor)*10000, (factor)*100000, \ - (factor)*1000000, (factor)*10000000, (factor)*100000000, \ - (factor)*1000000000 +#define FMT_POWERS_OF_10(factor) \ + factor * 10, (factor) * 100, (factor) * 1000, (factor) * 10000, \ + (factor) * 100000, (factor) * 1000000, (factor) * 10000000, \ + (factor) * 100000000, (factor) * 1000000000 // Converts value in the range [0, 100) to a string. -constexpr const char* digits2(size_t value) { +constexpr auto digits2(size_t value) -> const char* { // GCC generates slightly better code when value is pointer-size. return &"0001020304050607080910111213141516171819" "2021222324252627282930313233343536373839" @@ -1175,7 +1115,7 @@ constexpr const char* digits2(size_t value) { } // Sign is a template parameter to workaround a bug in gcc 4.8. -template <typename Char, typename Sign> constexpr Char sign(Sign s) { +template <typename Char, typename Sign> constexpr auto sign(Sign s) -> Char { #if !FMT_GCC_VERSION || FMT_GCC_VERSION >= 604 static_assert(std::is_same<Sign, sign_t>::value, ""); #endif @@ -1227,9 +1167,7 @@ inline auto do_count_digits(uint64_t n) -> int { // except for n == 0 in which case count_digits returns 1. FMT_CONSTEXPR20 inline auto count_digits(uint64_t n) -> int { #ifdef FMT_BUILTIN_CLZLL - if (!is_constant_evaluated()) { - return do_count_digits(n); - } + if (!is_constant_evaluated()) return do_count_digits(n); #endif return count_digits_fallback(n); } @@ -1257,7 +1195,7 @@ FMT_CONSTEXPR auto count_digits(UInt n) -> int { FMT_INLINE auto do_count_digits(uint32_t n) -> int { // An optimization by Kendall Willets from https://bit.ly/3uOIQrB. // This increments the upper 32 bits (log10(T) - 1) when >= T is added. -# define FMT_INC(T) (((sizeof(# T) - 1ull) << 32) - T) +# define FMT_INC(T) (((sizeof(#T) - 1ull) << 32) - T) static constexpr uint64_t table[] = { FMT_INC(0), FMT_INC(0), FMT_INC(0), // 8 FMT_INC(10), FMT_INC(10), FMT_INC(10), // 64 @@ -1375,7 +1313,7 @@ FMT_CONSTEXPR inline auto format_decimal(Iterator out, UInt value, int size) // Buffer is large enough to hold all digits (digits10 + 1). Char buffer[digits10<UInt>() + 1] = {}; auto end = format_decimal(buffer, value, size).end; - return {out, detail::copy_str_noinline<Char>(buffer, end, out)}; + return {out, detail::copy_noinline<Char>(buffer, end, out)}; } template <unsigned BASE_BITS, typename Char, typename UInt> @@ -1393,16 +1331,16 @@ FMT_CONSTEXPR auto format_uint(Char* buffer, UInt value, int num_digits, } template <unsigned BASE_BITS, typename Char, typename It, typename UInt> -inline auto format_uint(It out, UInt value, int num_digits, bool upper = false) - -> It { +FMT_CONSTEXPR inline auto format_uint(It out, UInt value, int num_digits, + bool upper = false) -> It { if (auto ptr = to_pointer<Char>(out, to_unsigned(num_digits))) { format_uint<BASE_BITS>(ptr, value, num_digits, upper); return out; } // Buffer should be large enough to hold all digits (digits / BASE_BITS + 1). - char buffer[num_bits<UInt>() / BASE_BITS + 1]; + char buffer[num_bits<UInt>() / BASE_BITS + 1] = {}; format_uint<BASE_BITS>(buffer, value, num_digits, upper); - return detail::copy_str_noinline<Char>(buffer, buffer + num_digits, out); + return detail::copy_noinline<Char>(buffer, buffer + num_digits, out); } // A converter from UTF-8 to UTF-16. @@ -1418,47 +1356,54 @@ class utf8_to_utf16 { auto str() const -> std::wstring { return {&buffer_[0], size()}; } }; +enum class to_utf8_error_policy { abort, replace }; + // A converter from UTF-16/UTF-32 (host endian) to UTF-8. -template <typename WChar, typename Buffer = memory_buffer> -class unicode_to_utf8 { +template <typename WChar, typename Buffer = memory_buffer> class to_utf8 { private: Buffer buffer_; public: - unicode_to_utf8() {} - explicit unicode_to_utf8(basic_string_view<WChar> s) { + to_utf8() {} + explicit to_utf8(basic_string_view<WChar> s, + to_utf8_error_policy policy = to_utf8_error_policy::abort) { static_assert(sizeof(WChar) == 2 || sizeof(WChar) == 4, "Expect utf16 or utf32"); - - if (!convert(s)) + if (!convert(s, policy)) FMT_THROW(std::runtime_error(sizeof(WChar) == 2 ? "invalid utf16" : "invalid utf32")); } operator string_view() const { return string_view(&buffer_[0], size()); } - size_t size() const { return buffer_.size() - 1; } - const char* c_str() const { return &buffer_[0]; } - std::string str() const { return std::string(&buffer_[0], size()); } + auto size() const -> size_t { return buffer_.size() - 1; } + auto c_str() const -> const char* { return &buffer_[0]; } + auto str() const -> std::string { return std::string(&buffer_[0], size()); } // Performs conversion returning a bool instead of throwing exception on // conversion error. This method may still throw in case of memory allocation // error. - bool convert(basic_string_view<WChar> s) { - if (!convert(buffer_, s)) return false; + auto convert(basic_string_view<WChar> s, + to_utf8_error_policy policy = to_utf8_error_policy::abort) + -> bool { + if (!convert(buffer_, s, policy)) return false; buffer_.push_back(0); return true; } - static bool convert(Buffer& buf, basic_string_view<WChar> s) { + static auto convert(Buffer& buf, basic_string_view<WChar> s, + to_utf8_error_policy policy = to_utf8_error_policy::abort) + -> bool { for (auto p = s.begin(); p != s.end(); ++p) { uint32_t c = static_cast<uint32_t>(*p); if (sizeof(WChar) == 2 && c >= 0xd800 && c <= 0xdfff) { - // surrogate pair + // Handle a surrogate pair. ++p; if (p == s.end() || (c & 0xfc00) != 0xd800 || (*p & 0xfc00) != 0xdc00) { - return false; + if (policy == to_utf8_error_policy::abort) return false; + buf.append(string_view("\xEF\xBF\xBD")); + --p; + } else { + c = (c << 10) + static_cast<uint32_t>(*p) - 0x35fdc00; } - c = (c << 10) + static_cast<uint32_t>(*p) - 0x35fdc00; - } - if (c < 0x80) { + } else if (c < 0x80) { buf.push_back(static_cast<char>(c)); } else if (c < 0x800) { buf.push_back(static_cast<char>(0xc0 | (c >> 6))); @@ -1481,14 +1426,14 @@ class unicode_to_utf8 { }; // Computes 128-bit result of multiplication of two 64-bit unsigned integers. -inline uint128_fallback umul128(uint64_t x, uint64_t y) noexcept { +inline auto umul128(uint64_t x, uint64_t y) noexcept -> uint128_fallback { #if FMT_USE_INT128 auto p = static_cast<uint128_opt>(x) * static_cast<uint128_opt>(y); return {static_cast<uint64_t>(p >> 64), static_cast<uint64_t>(p)}; #elif defined(_MSC_VER) && defined(_M_X64) - auto result = uint128_fallback(); - result.lo_ = _umul128(x, y, &result.hi_); - return result; + auto hi = uint64_t(); + auto lo = _umul128(x, y, &hi); + return {hi, lo}; #else const uint64_t mask = static_cast<uint64_t>(max_value<uint32_t>()); @@ -1512,19 +1457,19 @@ inline uint128_fallback umul128(uint64_t x, uint64_t y) noexcept { namespace dragonbox { // Computes floor(log10(pow(2, e))) for e in [-2620, 2620] using the method from // https://fmt.dev/papers/Dragonbox.pdf#page=28, section 6.1. -inline int floor_log10_pow2(int e) noexcept { +inline auto floor_log10_pow2(int e) noexcept -> int { FMT_ASSERT(e <= 2620 && e >= -2620, "too large exponent"); static_assert((-1 >> 1) == -1, "right shift is not arithmetic"); return (e * 315653) >> 20; } -inline int floor_log2_pow10(int e) noexcept { +inline auto floor_log2_pow10(int e) noexcept -> int { FMT_ASSERT(e <= 1233 && e >= -1233, "too large exponent"); return (e * 1741647) >> 19; } // Computes upper 64 bits of multiplication of two 64-bit unsigned integers. -inline uint64_t umul128_upper64(uint64_t x, uint64_t y) noexcept { +inline auto umul128_upper64(uint64_t x, uint64_t y) noexcept -> uint64_t { #if FMT_USE_INT128 auto p = static_cast<uint128_opt>(x) * static_cast<uint128_opt>(y); return static_cast<uint64_t>(p >> 64); @@ -1537,14 +1482,14 @@ inline uint64_t umul128_upper64(uint64_t x, uint64_t y) noexcept { // Computes upper 128 bits of multiplication of a 64-bit unsigned integer and a // 128-bit unsigned integer. -inline uint128_fallback umul192_upper128(uint64_t x, - uint128_fallback y) noexcept { +inline auto umul192_upper128(uint64_t x, uint128_fallback y) noexcept + -> uint128_fallback { uint128_fallback r = umul128(x, y.high()); r += umul128_upper64(x, y.low()); return r; } -FMT_API uint128_fallback get_cached_power(int k) noexcept; +FMT_API auto get_cached_power(int k) noexcept -> uint128_fallback; // Type-specific information that Dragonbox uses. template <typename T, typename Enable = void> struct float_info; @@ -1598,14 +1543,14 @@ template <typename T> FMT_API auto to_decimal(T x) noexcept -> decimal_fp<T>; } // namespace dragonbox // Returns true iff Float has the implicit bit which is not stored. -template <typename Float> constexpr bool has_implicit_bit() { +template <typename Float> constexpr auto has_implicit_bit() -> bool { // An 80-bit FP number has a 64-bit significand an no implicit bit. return std::numeric_limits<Float>::digits != 64; } // Returns the number of significand bits stored in Float. The implicit bit is // not counted since it is not stored. -template <typename Float> constexpr int num_significand_bits() { +template <typename Float> constexpr auto num_significand_bits() -> int { // std::numeric_limits may not support __float128. return is_float128<Float>() ? 112 : (std::numeric_limits<Float>::digits - @@ -1698,7 +1643,7 @@ using fp = basic_fp<unsigned long long>; // Normalizes the value converted from double and multiplied by (1 << SHIFT). template <int SHIFT = 0, typename F> -FMT_CONSTEXPR basic_fp<F> normalize(basic_fp<F> value) { +FMT_CONSTEXPR auto normalize(basic_fp<F> value) -> basic_fp<F> { // Handle subnormals. const auto implicit_bit = F(1) << num_significand_bits<double>(); const auto shifted_implicit_bit = implicit_bit << SHIFT; @@ -1715,7 +1660,7 @@ FMT_CONSTEXPR basic_fp<F> normalize(basic_fp<F> value) { } // Computes lhs * rhs / pow(2, 64) rounded to nearest with half-up tie breaking. -FMT_CONSTEXPR inline uint64_t multiply(uint64_t lhs, uint64_t rhs) { +FMT_CONSTEXPR inline auto multiply(uint64_t lhs, uint64_t rhs) -> uint64_t { #if FMT_USE_INT128 auto product = static_cast<__uint128_t>(lhs) * rhs; auto f = static_cast<uint64_t>(product >> 64); @@ -1732,147 +1677,36 @@ FMT_CONSTEXPR inline uint64_t multiply(uint64_t lhs, uint64_t rhs) { #endif } -FMT_CONSTEXPR inline fp operator*(fp x, fp y) { +FMT_CONSTEXPR inline auto operator*(fp x, fp y) -> fp { return {multiply(x.f, y.f), x.e + y.e + 64}; } -template <typename T = void> struct basic_data { - // Normalized 64-bit significands of pow(10, k), for k = -348, -340, ..., 340. - // These are generated by support/compute-powers.py. - static constexpr uint64_t pow10_significands[87] = { - 0xfa8fd5a0081c0288, 0xbaaee17fa23ebf76, 0x8b16fb203055ac76, - 0xcf42894a5dce35ea, 0x9a6bb0aa55653b2d, 0xe61acf033d1a45df, - 0xab70fe17c79ac6ca, 0xff77b1fcbebcdc4f, 0xbe5691ef416bd60c, - 0x8dd01fad907ffc3c, 0xd3515c2831559a83, 0x9d71ac8fada6c9b5, - 0xea9c227723ee8bcb, 0xaecc49914078536d, 0x823c12795db6ce57, - 0xc21094364dfb5637, 0x9096ea6f3848984f, 0xd77485cb25823ac7, - 0xa086cfcd97bf97f4, 0xef340a98172aace5, 0xb23867fb2a35b28e, - 0x84c8d4dfd2c63f3b, 0xc5dd44271ad3cdba, 0x936b9fcebb25c996, - 0xdbac6c247d62a584, 0xa3ab66580d5fdaf6, 0xf3e2f893dec3f126, - 0xb5b5ada8aaff80b8, 0x87625f056c7c4a8b, 0xc9bcff6034c13053, - 0x964e858c91ba2655, 0xdff9772470297ebd, 0xa6dfbd9fb8e5b88f, - 0xf8a95fcf88747d94, 0xb94470938fa89bcf, 0x8a08f0f8bf0f156b, - 0xcdb02555653131b6, 0x993fe2c6d07b7fac, 0xe45c10c42a2b3b06, - 0xaa242499697392d3, 0xfd87b5f28300ca0e, 0xbce5086492111aeb, - 0x8cbccc096f5088cc, 0xd1b71758e219652c, 0x9c40000000000000, - 0xe8d4a51000000000, 0xad78ebc5ac620000, 0x813f3978f8940984, - 0xc097ce7bc90715b3, 0x8f7e32ce7bea5c70, 0xd5d238a4abe98068, - 0x9f4f2726179a2245, 0xed63a231d4c4fb27, 0xb0de65388cc8ada8, - 0x83c7088e1aab65db, 0xc45d1df942711d9a, 0x924d692ca61be758, - 0xda01ee641a708dea, 0xa26da3999aef774a, 0xf209787bb47d6b85, - 0xb454e4a179dd1877, 0x865b86925b9bc5c2, 0xc83553c5c8965d3d, - 0x952ab45cfa97a0b3, 0xde469fbd99a05fe3, 0xa59bc234db398c25, - 0xf6c69a72a3989f5c, 0xb7dcbf5354e9bece, 0x88fcf317f22241e2, - 0xcc20ce9bd35c78a5, 0x98165af37b2153df, 0xe2a0b5dc971f303a, - 0xa8d9d1535ce3b396, 0xfb9b7cd9a4a7443c, 0xbb764c4ca7a44410, - 0x8bab8eefb6409c1a, 0xd01fef10a657842c, 0x9b10a4e5e9913129, - 0xe7109bfba19c0c9d, 0xac2820d9623bf429, 0x80444b5e7aa7cf85, - 0xbf21e44003acdd2d, 0x8e679c2f5e44ff8f, 0xd433179d9c8cb841, - 0x9e19db92b4e31ba9, 0xeb96bf6ebadf77d9, 0xaf87023b9bf0ee6b, - }; - -#if FMT_GCC_VERSION && FMT_GCC_VERSION < 409 -# pragma GCC diagnostic push -# pragma GCC diagnostic ignored "-Wnarrowing" -#endif - // Binary exponents of pow(10, k), for k = -348, -340, ..., 340, corresponding - // to significands above. - static constexpr int16_t pow10_exponents[87] = { - -1220, -1193, -1166, -1140, -1113, -1087, -1060, -1034, -1007, -980, -954, - -927, -901, -874, -847, -821, -794, -768, -741, -715, -688, -661, - -635, -608, -582, -555, -529, -502, -475, -449, -422, -396, -369, - -343, -316, -289, -263, -236, -210, -183, -157, -130, -103, -77, - -50, -24, 3, 30, 56, 83, 109, 136, 162, 189, 216, - 242, 269, 295, 322, 348, 375, 402, 428, 455, 481, 508, - 534, 561, 588, 614, 641, 667, 694, 720, 747, 774, 800, - 827, 853, 880, 907, 933, 960, 986, 1013, 1039, 1066}; -#if FMT_GCC_VERSION && FMT_GCC_VERSION < 409 -# pragma GCC diagnostic pop -#endif - - static constexpr uint64_t power_of_10_64[20] = { - 1, FMT_POWERS_OF_10(1ULL), FMT_POWERS_OF_10(1000000000ULL), - 10000000000000000000ULL}; - - // For checking rounding thresholds. - // The kth entry is chosen to be the smallest integer such that the - // upper 32-bits of 10^(k+1) times it is strictly bigger than 5 * 10^k. - static constexpr uint32_t fractional_part_rounding_thresholds[8] = { - 2576980378, // ceil(2^31 + 2^32/10^1) - 2190433321, // ceil(2^31 + 2^32/10^2) - 2151778616, // ceil(2^31 + 2^32/10^3) - 2147913145, // ceil(2^31 + 2^32/10^4) - 2147526598, // ceil(2^31 + 2^32/10^5) - 2147487943, // ceil(2^31 + 2^32/10^6) - 2147484078, // ceil(2^31 + 2^32/10^7) - 2147483691 // ceil(2^31 + 2^32/10^8) - }; -}; - -#if FMT_CPLUSPLUS < 201703L -template <typename T> constexpr uint64_t basic_data<T>::pow10_significands[]; -template <typename T> constexpr int16_t basic_data<T>::pow10_exponents[]; -template <typename T> constexpr uint64_t basic_data<T>::power_of_10_64[]; -template <typename T> -constexpr uint32_t basic_data<T>::fractional_part_rounding_thresholds[]; -#endif - -// This is a struct rather than an alias to avoid shadowing warnings in gcc. -struct data : basic_data<> {}; - -// Returns a cached power of 10 `c_k = c_k.f * pow(2, c_k.e)` such that its -// (binary) exponent satisfies `min_exponent <= c_k.e <= min_exponent + 28`. -FMT_CONSTEXPR inline fp get_cached_power(int min_exponent, - int& pow10_exponent) { - const int shift = 32; - // log10(2) = 0x0.4d104d427de7fbcc... - const int64_t significand = 0x4d104d427de7fbcc; - int index = static_cast<int>( - ((min_exponent + fp::num_significand_bits - 1) * (significand >> shift) + - ((int64_t(1) << shift) - 1)) // ceil - >> 32 // arithmetic shift - ); - // Decimal exponent of the first (smallest) cached power of 10. - const int first_dec_exp = -348; - // Difference between 2 consecutive decimal exponents in cached powers of 10. - const int dec_exp_step = 8; - index = (index - first_dec_exp - 1) / dec_exp_step + 1; - pow10_exponent = first_dec_exp + index * dec_exp_step; - // Using *(x + index) instead of x[index] avoids an issue with some compilers - // using the EDG frontend (e.g. nvhpc/22.3 in C++17 mode). - return {*(data::pow10_significands + index), - *(data::pow10_exponents + index)}; -} - -template <typename T> +template <typename T, bool doublish = num_bits<T>() == num_bits<double>()> using convert_float_result = - conditional_t<std::is_same<T, float>::value || - std::numeric_limits<T>::digits == - std::numeric_limits<double>::digits, - double, T>; + conditional_t<std::is_same<T, float>::value || doublish, double, T>; template <typename T> constexpr auto convert_float(T value) -> convert_float_result<T> { return static_cast<convert_float_result<T>>(value); } -template <typename OutputIt, typename Char> -FMT_NOINLINE FMT_CONSTEXPR auto fill(OutputIt it, size_t n, - const fill_t<Char>& fill) -> OutputIt { +template <typename Char, typename OutputIt> +FMT_NOINLINE FMT_CONSTEXPR auto fill(OutputIt it, size_t n, const fill_t& fill) + -> OutputIt { auto fill_size = fill.size(); - if (fill_size == 1) return detail::fill_n(it, n, fill[0]); - auto data = fill.data(); - for (size_t i = 0; i < n; ++i) - it = copy_str<Char>(data, data + fill_size, it); + if (fill_size == 1) return detail::fill_n(it, n, fill.template get<Char>()); + if (const Char* data = fill.template data<Char>()) { + for (size_t i = 0; i < n; ++i) it = copy<Char>(data, data + fill_size, it); + } return it; } // Writes the output of f, padded according to format specifications in specs. // size: output size in code units. // width: output display width in (terminal) column positions. -template <align::type align = align::left, typename OutputIt, typename Char, +template <typename Char, align::type align = align::left, typename OutputIt, typename F> -FMT_CONSTEXPR auto write_padded(OutputIt out, const format_specs<Char>& specs, +FMT_CONSTEXPR auto write_padded(OutputIt out, const format_specs& specs, size_t size, size_t width, F&& f) -> OutputIt { static_assert(align == align::left || align == align::right, ""); unsigned spec_width = to_unsigned(specs.width); @@ -1883,31 +1717,31 @@ FMT_CONSTEXPR auto write_padded(OutputIt out, const format_specs<Char>& specs, size_t left_padding = padding >> shifts[specs.align]; size_t right_padding = padding - left_padding; auto it = reserve(out, size + padding * specs.fill.size()); - if (left_padding != 0) it = fill(it, left_padding, specs.fill); + if (left_padding != 0) it = fill<Char>(it, left_padding, specs.fill); it = f(it); - if (right_padding != 0) it = fill(it, right_padding, specs.fill); + if (right_padding != 0) it = fill<Char>(it, right_padding, specs.fill); return base_iterator(out, it); } -template <align::type align = align::left, typename OutputIt, typename Char, +template <typename Char, align::type align = align::left, typename OutputIt, typename F> -constexpr auto write_padded(OutputIt out, const format_specs<Char>& specs, +constexpr auto write_padded(OutputIt out, const format_specs& specs, size_t size, F&& f) -> OutputIt { - return write_padded<align>(out, specs, size, size, f); + return write_padded<Char, align>(out, specs, size, size, f); } -template <align::type align = align::left, typename Char, typename OutputIt> +template <typename Char, align::type align = align::left, typename OutputIt> FMT_CONSTEXPR auto write_bytes(OutputIt out, string_view bytes, - const format_specs<Char>& specs) -> OutputIt { - return write_padded<align>( + const format_specs& specs = {}) -> OutputIt { + return write_padded<Char, align>( out, specs, bytes.size(), [bytes](reserve_iterator<OutputIt> it) { const char* data = bytes.data(); - return copy_str<Char>(data, data + bytes.size(), it); + return copy<Char>(data, data + bytes.size(), it); }); } template <typename Char, typename OutputIt, typename UIntPtr> -auto write_ptr(OutputIt out, UIntPtr value, const format_specs<Char>* specs) +auto write_ptr(OutputIt out, UIntPtr value, const format_specs* specs) -> OutputIt { int num_digits = count_digits<4>(value); auto size = to_unsigned(num_digits) + size_t(2); @@ -1916,7 +1750,7 @@ auto write_ptr(OutputIt out, UIntPtr value, const format_specs<Char>* specs) *it++ = static_cast<Char>('x'); return format_uint<4, Char>(it, value, num_digits); }; - return specs ? write_padded<align::right>(out, *specs, size, write) + return specs ? write_padded<Char, align::right>(out, *specs, size, write) : base_iterator(out, write(reserve(out, size))); } @@ -1935,16 +1769,10 @@ template <typename Char> struct find_escape_result { }; template <typename Char> -using make_unsigned_char = - typename conditional_t<std::is_integral<Char>::value, - std::make_unsigned<Char>, - type_identity<uint32_t>>::type; - -template <typename Char> auto find_escape(const Char* begin, const Char* end) -> find_escape_result<Char> { for (; begin != end; ++begin) { - uint32_t cp = static_cast<make_unsigned_char<Char>>(*begin); + uint32_t cp = static_cast<unsigned_char<Char>>(*begin); if (const_check(sizeof(Char) == 1) && cp >= 0x80) continue; if (needs_escape(cp)) return {begin, begin + 1, cp}; } @@ -1953,7 +1781,7 @@ auto find_escape(const Char* begin, const Char* end) inline auto find_escape(const char* begin, const char* end) -> find_escape_result<char> { - if (!is_utf8()) return find_escape<char>(begin, end); + if (!use_utf8()) return find_escape<char>(begin, end); auto result = find_escape_result<char>{end, nullptr, 0}; for_each_codepoint(string_view(begin, to_unsigned(end - begin)), [&](uint32_t cp, string_view sv) { @@ -1970,7 +1798,7 @@ inline auto find_escape(const char* begin, const char* end) [] { \ /* Use the hidden visibility as a workaround for a GCC bug (#1973). */ \ /* Use a macro-like name to avoid shadowing warnings. */ \ - struct FMT_GCC_VISIBILITY_HIDDEN FMT_COMPILE_STRING : base { \ + struct FMT_VISIBILITY("hidden") FMT_COMPILE_STRING : base { \ using char_type FMT_MAYBE_UNUSED = fmt::remove_cvref_t<decltype(s[0])>; \ FMT_MAYBE_UNUSED FMT_CONSTEXPR explicit \ operator fmt::basic_string_view<char_type>() const { \ @@ -1981,14 +1809,12 @@ inline auto find_escape(const char* begin, const char* end) }() /** - \rst - Constructs a compile-time format string from a string literal *s*. - - **Example**:: - - // A compile-time error because 'd' is an invalid specifier for strings. - std::string s = fmt::format(FMT_STRING("{:d}"), "foo"); - \endrst + * Constructs a compile-time format string from a string literal `s`. + * + * **Example**: + * + * // A compile-time error because 'd' is an invalid specifier for strings. + * std::string s = fmt::format(FMT_STRING("{:d}"), "foo"); */ #define FMT_STRING(s) FMT_STRING_IMPL(s, fmt::detail::compile_string, ) @@ -1999,7 +1825,7 @@ auto write_codepoint(OutputIt out, char prefix, uint32_t cp) -> OutputIt { Char buf[width]; fill_n(buf, width, static_cast<Char>('0')); format_uint<4>(buf, cp, width); - return copy_str<Char>(buf, buf + width, out); + return copy<Char>(buf, buf + width, out); } template <typename OutputIt, typename Char> @@ -2027,15 +1853,11 @@ auto write_escaped_cp(OutputIt out, const find_escape_result<Char>& escape) *out++ = static_cast<Char>('\\'); break; default: - if (escape.cp < 0x100) { - return write_codepoint<2, Char>(out, 'x', escape.cp); - } - if (escape.cp < 0x10000) { + if (escape.cp < 0x100) return write_codepoint<2, Char>(out, 'x', escape.cp); + if (escape.cp < 0x10000) return write_codepoint<4, Char>(out, 'u', escape.cp); - } - if (escape.cp < 0x110000) { + if (escape.cp < 0x110000) return write_codepoint<8, Char>(out, 'U', escape.cp); - } for (Char escape_char : basic_string_view<Char>( escape.begin, to_unsigned(escape.end - escape.begin))) { out = write_codepoint<2, Char>(out, 'x', @@ -2054,7 +1876,7 @@ auto write_escaped_string(OutputIt out, basic_string_view<Char> str) auto begin = str.begin(), end = str.end(); do { auto escape = find_escape(begin, end); - out = copy_str<Char>(begin, escape.begin, out); + out = copy<Char>(begin, escape.begin, out); begin = escape.end; if (!begin) break; out = write_escaped_cp<OutputIt, Char>(out, escape); @@ -2065,11 +1887,13 @@ auto write_escaped_string(OutputIt out, basic_string_view<Char> str) template <typename Char, typename OutputIt> auto write_escaped_char(OutputIt out, Char v) -> OutputIt { + Char v_array[1] = {v}; *out++ = static_cast<Char>('\''); if ((needs_escape(static_cast<uint32_t>(v)) && v != static_cast<Char>('"')) || v == static_cast<Char>('\'')) { - out = write_escaped_cp( - out, find_escape_result<Char>{&v, &v + 1, static_cast<uint32_t>(v)}); + out = write_escaped_cp(out, + find_escape_result<Char>{v_array, v_array + 1, + static_cast<uint32_t>(v)}); } else { *out++ = v; } @@ -2079,24 +1903,23 @@ auto write_escaped_char(OutputIt out, Char v) -> OutputIt { template <typename Char, typename OutputIt> FMT_CONSTEXPR auto write_char(OutputIt out, Char value, - const format_specs<Char>& specs) -> OutputIt { + const format_specs& specs) -> OutputIt { bool is_debug = specs.type == presentation_type::debug; - return write_padded(out, specs, 1, [=](reserve_iterator<OutputIt> it) { + return write_padded<Char>(out, specs, 1, [=](reserve_iterator<OutputIt> it) { if (is_debug) return write_escaped_char(it, value); *it++ = value; return it; }); } template <typename Char, typename OutputIt> -FMT_CONSTEXPR auto write(OutputIt out, Char value, - const format_specs<Char>& specs, locale_ref loc = {}) - -> OutputIt { +FMT_CONSTEXPR auto write(OutputIt out, Char value, const format_specs& specs, + locale_ref loc = {}) -> OutputIt { // char is formatted as unsigned char for consistency across platforms. using unsigned_type = conditional_t<std::is_same<Char, char>::value, unsigned char, unsigned>; return check_char_specs(specs) - ? write_char(out, value, specs) - : write(out, static_cast<unsigned_type>(value), specs, loc); + ? write_char<Char>(out, value, specs) + : write<Char>(out, static_cast<unsigned_type>(value), specs, loc); } // Data for write_int that doesn't depend on output iterator type. It is used to @@ -2106,7 +1929,7 @@ template <typename Char> struct write_int_data { size_t padding; FMT_CONSTEXPR write_int_data(int num_digits, unsigned prefix, - const format_specs<Char>& specs) + const format_specs& specs) : size((prefix >> 24) + to_unsigned(num_digits)), padding(0) { if (specs.align == align::numeric) { auto width = to_unsigned(specs.width); @@ -2125,10 +1948,10 @@ template <typename Char> struct write_int_data { // <left-padding><prefix><numeric-padding><digits><right-padding> // where <digits> are written by write_digits(it). // prefix contains chars in three lower bytes and the size in the fourth byte. -template <typename OutputIt, typename Char, typename W> +template <typename Char, typename OutputIt, typename W> FMT_CONSTEXPR FMT_INLINE auto write_int(OutputIt out, int num_digits, unsigned prefix, - const format_specs<Char>& specs, + const format_specs& specs, W write_digits) -> OutputIt { // Slightly faster check for specs.width == 0 && specs.precision == -1. if ((specs.width | (specs.precision + 1)) == 0) { @@ -2140,7 +1963,7 @@ FMT_CONSTEXPR FMT_INLINE auto write_int(OutputIt out, int num_digits, return base_iterator(out, write_digits(it)); } auto data = write_int_data<Char>(num_digits, prefix, specs); - return write_padded<align::right>( + return write_padded<Char, align::right>( out, specs, data.size, [=](reserve_iterator<OutputIt> it) { for (unsigned p = prefix & 0xffffff; p != 0; p >>= 8) *it++ = static_cast<Char>(p & 0xff); @@ -2158,10 +1981,10 @@ template <typename Char> class digit_grouping { std::string::const_iterator group; int pos; }; - next_state initial_state() const { return {grouping_.begin(), 0}; } + auto initial_state() const -> next_state { return {grouping_.begin(), 0}; } // Returns the next digit group separator position. - int next(next_state& state) const { + auto next(next_state& state) const -> int { if (thousands_sep_.empty()) return max_value<int>(); if (state.group == grouping_.end()) return state.pos += grouping_.back(); if (*state.group <= 0 || *state.group == max_value<char>()) @@ -2180,9 +2003,9 @@ template <typename Char> class digit_grouping { digit_grouping(std::string grouping, std::basic_string<Char> sep) : grouping_(std::move(grouping)), thousands_sep_(std::move(sep)) {} - bool has_separator() const { return !thousands_sep_.empty(); } + auto has_separator() const -> bool { return !thousands_sep_.empty(); } - int count_separators(int num_digits) const { + auto count_separators(int num_digits) const -> int { int count = 0; auto state = initial_state(); while (num_digits > next(state)) ++count; @@ -2191,7 +2014,7 @@ template <typename Char> class digit_grouping { // Applies grouping to digits and write the output to out. template <typename Out, typename C> - Out apply(Out out, basic_string_view<C> digits) const { + auto apply(Out out, basic_string_view<C> digits) const -> Out { auto num_digits = static_cast<int>(digits.size()); auto separators = basic_memory_buffer<int>(); separators.push_back(0); @@ -2203,9 +2026,8 @@ template <typename Char> class digit_grouping { for (int i = 0, sep_index = static_cast<int>(separators.size() - 1); i < num_digits; ++i) { if (num_digits - i == separators[sep_index]) { - out = - copy_str<Char>(thousands_sep_.data(), - thousands_sep_.data() + thousands_sep_.size(), out); + out = copy<Char>(thousands_sep_.data(), + thousands_sep_.data() + thousands_sep_.size(), out); --sep_index; } *out++ = static_cast<Char>(digits[to_unsigned(i)]); @@ -2214,41 +2036,71 @@ template <typename Char> class digit_grouping { } }; +FMT_CONSTEXPR inline void prefix_append(unsigned& prefix, unsigned value) { + prefix |= prefix != 0 ? value << 8 : value; + prefix += (1u + (value > 0xff ? 1 : 0)) << 24; +} + // Writes a decimal integer with digit grouping. template <typename OutputIt, typename UInt, typename Char> auto write_int(OutputIt out, UInt value, unsigned prefix, - const format_specs<Char>& specs, - const digit_grouping<Char>& grouping) -> OutputIt { + const format_specs& specs, const digit_grouping<Char>& grouping) + -> OutputIt { static_assert(std::is_same<uint64_or_128_t<UInt>, UInt>::value, ""); - int num_digits = count_digits(value); - char digits[40]; - format_decimal(digits, value, num_digits); - unsigned size = to_unsigned((prefix != 0 ? 1 : 0) + num_digits + - grouping.count_separators(num_digits)); - return write_padded<align::right>( + int num_digits = 0; + auto buffer = memory_buffer(); + switch (specs.type) { + default: + FMT_ASSERT(false, ""); + FMT_FALLTHROUGH; + case presentation_type::none: + case presentation_type::dec: + num_digits = count_digits(value); + format_decimal<char>(appender(buffer), value, num_digits); + break; + case presentation_type::hex: + if (specs.alt) + prefix_append(prefix, unsigned(specs.upper ? 'X' : 'x') << 8 | '0'); + num_digits = count_digits<4>(value); + format_uint<4, char>(appender(buffer), value, num_digits, specs.upper); + break; + case presentation_type::oct: + num_digits = count_digits<3>(value); + // Octal prefix '0' is counted as a digit, so only add it if precision + // is not greater than the number of digits. + if (specs.alt && specs.precision <= num_digits && value != 0) + prefix_append(prefix, '0'); + format_uint<3, char>(appender(buffer), value, num_digits); + break; + case presentation_type::bin: + if (specs.alt) + prefix_append(prefix, unsigned(specs.upper ? 'B' : 'b') << 8 | '0'); + num_digits = count_digits<1>(value); + format_uint<1, char>(appender(buffer), value, num_digits); + break; + case presentation_type::chr: + return write_char<Char>(out, static_cast<Char>(value), specs); + } + + unsigned size = (prefix != 0 ? prefix >> 24 : 0) + to_unsigned(num_digits) + + to_unsigned(grouping.count_separators(num_digits)); + return write_padded<Char, align::right>( out, specs, size, size, [&](reserve_iterator<OutputIt> it) { - if (prefix != 0) { - char sign = static_cast<char>(prefix); - *it++ = static_cast<Char>(sign); - } - return grouping.apply(it, string_view(digits, to_unsigned(num_digits))); + for (unsigned p = prefix & 0xffffff; p != 0; p >>= 8) + *it++ = static_cast<Char>(p & 0xff); + return grouping.apply(it, string_view(buffer.data(), buffer.size())); }); } // Writes a localized value. -FMT_API auto write_loc(appender out, loc_value value, - const format_specs<>& specs, locale_ref loc) -> bool; -template <typename OutputIt, typename Char> -inline auto write_loc(OutputIt, loc_value, const format_specs<Char>&, - locale_ref) -> bool { +FMT_API auto write_loc(appender out, loc_value value, const format_specs& specs, + locale_ref loc) -> bool; +template <typename OutputIt> +inline auto write_loc(OutputIt, loc_value, const format_specs&, locale_ref) + -> bool { return false; } -FMT_CONSTEXPR inline void prefix_append(unsigned& prefix, unsigned value) { - prefix |= prefix != 0 ? value << 8 : value; - prefix += (1u + (value > 0xff ? 1 : 0)) << 24; -} - template <typename UInt> struct write_int_arg { UInt abs_value; unsigned prefix; @@ -2271,8 +2123,8 @@ FMT_CONSTEXPR auto make_write_int_arg(T value, sign_t sign) } template <typename Char = char> struct loc_writer { - buffer_appender<Char> out; - const format_specs<Char>& specs; + basic_appender<Char> out; + const format_specs& specs; std::basic_string<Char> sep; std::string grouping; std::basic_string<Char> decimal_point; @@ -2293,87 +2145,86 @@ template <typename Char = char> struct loc_writer { template <typename Char, typename OutputIt, typename T> FMT_CONSTEXPR FMT_INLINE auto write_int(OutputIt out, write_int_arg<T> arg, - const format_specs<Char>& specs, - locale_ref) -> OutputIt { + const format_specs& specs, locale_ref) + -> OutputIt { static_assert(std::is_same<T, uint32_or_64_or_128_t<T>>::value, ""); auto abs_value = arg.abs_value; auto prefix = arg.prefix; switch (specs.type) { + default: + FMT_ASSERT(false, ""); + FMT_FALLTHROUGH; case presentation_type::none: case presentation_type::dec: { - auto num_digits = count_digits(abs_value); - return write_int( + int num_digits = count_digits(abs_value); + return write_int<Char>( out, num_digits, prefix, specs, [=](reserve_iterator<OutputIt> it) { return format_decimal<Char>(it, abs_value, num_digits).end; }); } - case presentation_type::hex_lower: - case presentation_type::hex_upper: { - bool upper = specs.type == presentation_type::hex_upper; + case presentation_type::hex: { if (specs.alt) - prefix_append(prefix, unsigned(upper ? 'X' : 'x') << 8 | '0'); + prefix_append(prefix, unsigned(specs.upper ? 'X' : 'x') << 8 | '0'); int num_digits = count_digits<4>(abs_value); - return write_int( + return write_int<Char>( out, num_digits, prefix, specs, [=](reserve_iterator<OutputIt> it) { - return format_uint<4, Char>(it, abs_value, num_digits, upper); + return format_uint<4, Char>(it, abs_value, num_digits, specs.upper); }); } - case presentation_type::bin_lower: - case presentation_type::bin_upper: { - bool upper = specs.type == presentation_type::bin_upper; - if (specs.alt) - prefix_append(prefix, unsigned(upper ? 'B' : 'b') << 8 | '0'); - int num_digits = count_digits<1>(abs_value); - return write_int(out, num_digits, prefix, specs, - [=](reserve_iterator<OutputIt> it) { - return format_uint<1, Char>(it, abs_value, num_digits); - }); - } case presentation_type::oct: { int num_digits = count_digits<3>(abs_value); // Octal prefix '0' is counted as a digit, so only add it if precision // is not greater than the number of digits. if (specs.alt && specs.precision <= num_digits && abs_value != 0) prefix_append(prefix, '0'); - return write_int(out, num_digits, prefix, specs, - [=](reserve_iterator<OutputIt> it) { - return format_uint<3, Char>(it, abs_value, num_digits); - }); + return write_int<Char>( + out, num_digits, prefix, specs, [=](reserve_iterator<OutputIt> it) { + return format_uint<3, Char>(it, abs_value, num_digits); + }); + } + case presentation_type::bin: { + if (specs.alt) + prefix_append(prefix, unsigned(specs.upper ? 'B' : 'b') << 8 | '0'); + int num_digits = count_digits<1>(abs_value); + return write_int<Char>( + out, num_digits, prefix, specs, [=](reserve_iterator<OutputIt> it) { + return format_uint<1, Char>(it, abs_value, num_digits); + }); } case presentation_type::chr: - return write_char(out, static_cast<Char>(abs_value), specs); - default: - throw_format_error("invalid format specifier"); + return write_char<Char>(out, static_cast<Char>(abs_value), specs); } - return out; } template <typename Char, typename OutputIt, typename T> -FMT_CONSTEXPR FMT_NOINLINE auto write_int_noinline( - OutputIt out, write_int_arg<T> arg, const format_specs<Char>& specs, - locale_ref loc) -> OutputIt { - return write_int(out, arg, specs, loc); +FMT_CONSTEXPR FMT_NOINLINE auto write_int_noinline(OutputIt out, + write_int_arg<T> arg, + const format_specs& specs, + locale_ref loc) -> OutputIt { + return write_int<Char>(out, arg, specs, loc); } -template <typename Char, typename OutputIt, typename T, +template <typename Char, typename T, FMT_ENABLE_IF(is_integral<T>::value && !std::is_same<T, bool>::value && - std::is_same<OutputIt, buffer_appender<Char>>::value)> -FMT_CONSTEXPR FMT_INLINE auto write(OutputIt out, T value, - const format_specs<Char>& specs, - locale_ref loc) -> OutputIt { + !std::is_same<T, Char>::value)> +FMT_CONSTEXPR FMT_INLINE auto write(basic_appender<Char> out, T value, + const format_specs& specs, locale_ref loc) + -> basic_appender<Char> { if (specs.localized && write_loc(out, value, specs, loc)) return out; - return write_int_noinline(out, make_write_int_arg(value, specs.sign), specs, - loc); + return write_int_noinline<Char>(out, make_write_int_arg(value, specs.sign), + specs, loc); } // An inlined version of write used in format string compilation. template <typename Char, typename OutputIt, typename T, FMT_ENABLE_IF(is_integral<T>::value && !std::is_same<T, bool>::value && - !std::is_same<OutputIt, buffer_appender<Char>>::value)> + !std::is_same<T, Char>::value && + !std::is_same<OutputIt, basic_appender<Char>>::value)> FMT_CONSTEXPR FMT_INLINE auto write(OutputIt out, T value, - const format_specs<Char>& specs, - locale_ref loc) -> OutputIt { + const format_specs& specs, locale_ref loc) + -> OutputIt { if (specs.localized && write_loc(out, value, specs, loc)) return out; - return write_int(out, make_write_int_arg(value, specs.sign), specs, loc); + return write_int<Char>(out, make_write_int_arg(value, specs.sign), specs, + loc); } // An output iterator that counts the number of objects written to it and @@ -2395,62 +2246,64 @@ class counting_iterator { FMT_CONSTEXPR counting_iterator() : count_(0) {} - FMT_CONSTEXPR size_t count() const { return count_; } + FMT_CONSTEXPR auto count() const -> size_t { return count_; } - FMT_CONSTEXPR counting_iterator& operator++() { + FMT_CONSTEXPR auto operator++() -> counting_iterator& { ++count_; return *this; } - FMT_CONSTEXPR counting_iterator operator++(int) { + FMT_CONSTEXPR auto operator++(int) -> counting_iterator { auto it = *this; ++*this; return it; } - FMT_CONSTEXPR friend counting_iterator operator+(counting_iterator it, - difference_type n) { + FMT_CONSTEXPR friend auto operator+(counting_iterator it, difference_type n) + -> counting_iterator { it.count_ += static_cast<size_t>(n); return it; } - FMT_CONSTEXPR value_type operator*() const { return {}; } + FMT_CONSTEXPR auto operator*() const -> value_type { return {}; } }; template <typename Char, typename OutputIt> FMT_CONSTEXPR auto write(OutputIt out, basic_string_view<Char> s, - const format_specs<Char>& specs) -> OutputIt { + const format_specs& specs) -> OutputIt { auto data = s.data(); auto size = s.size(); if (specs.precision >= 0 && to_unsigned(specs.precision) < size) size = code_point_index(s, to_unsigned(specs.precision)); bool is_debug = specs.type == presentation_type::debug; size_t width = 0; + + if (is_debug) size = write_escaped_string(counting_iterator{}, s).count(); + if (specs.width != 0) { if (is_debug) - width = write_escaped_string(counting_iterator{}, s).count(); + width = size; else width = compute_width(basic_string_view<Char>(data, size)); } - return write_padded(out, specs, size, width, - [=](reserve_iterator<OutputIt> it) { - if (is_debug) return write_escaped_string(it, s); - return copy_str<Char>(data, data + size, it); - }); + return write_padded<Char>(out, specs, size, width, + [=](reserve_iterator<OutputIt> it) { + if (is_debug) return write_escaped_string(it, s); + return copy<Char>(data, data + size, it); + }); } template <typename Char, typename OutputIt> FMT_CONSTEXPR auto write(OutputIt out, basic_string_view<type_identity_t<Char>> s, - const format_specs<Char>& specs, locale_ref) - -> OutputIt { - return write(out, s, specs); + const format_specs& specs, locale_ref) -> OutputIt { + return write<Char>(out, s, specs); } template <typename Char, typename OutputIt> -FMT_CONSTEXPR auto write(OutputIt out, const Char* s, - const format_specs<Char>& specs, locale_ref) - -> OutputIt { - return specs.type != presentation_type::pointer - ? write(out, basic_string_view<Char>(s), specs, {}) - : write_ptr<Char>(out, bit_cast<uintptr_t>(s), &specs); +FMT_CONSTEXPR auto write(OutputIt out, const Char* s, const format_specs& specs, + locale_ref) -> OutputIt { + if (specs.type == presentation_type::pointer) + return write_ptr<Char>(out, bit_cast<uintptr_t>(s), &specs); + if (!s) report_error("string pointer is null"); + return write<Char>(out, basic_string_view<Char>(s), specs, {}); } template <typename Char, typename OutputIt, typename T, @@ -2475,63 +2328,87 @@ FMT_CONSTEXPR auto write(OutputIt out, T value) -> OutputIt { return base_iterator(out, it); } +// DEPRECATED! +template <typename Char> +FMT_CONSTEXPR auto parse_align(const Char* begin, const Char* end, + format_specs& specs) -> const Char* { + FMT_ASSERT(begin != end, ""); + auto align = align::none; + auto p = begin + code_point_length(begin); + if (end - p <= 0) p = begin; + for (;;) { + switch (to_ascii(*p)) { + case '<': + align = align::left; + break; + case '>': + align = align::right; + break; + case '^': + align = align::center; + break; + } + if (align != align::none) { + if (p != begin) { + auto c = *begin; + if (c == '}') return begin; + if (c == '{') { + report_error("invalid fill character '{'"); + return begin; + } + specs.fill = basic_string_view<Char>(begin, to_unsigned(p - begin)); + begin = p + 1; + } else { + ++begin; + } + break; + } else if (p == begin) { + break; + } + p = begin; + } + specs.align = align; + return begin; +} + // A floating-point presentation format. enum class float_format : unsigned char { general, // General: exponent notation or fixed point based on magnitude. exp, // Exponent notation with the default precision of 6, e.g. 1.2e-3. - fixed, // Fixed point with the default precision of 6, e.g. 0.0012. - hex + fixed // Fixed point with the default precision of 6, e.g. 0.0012. }; struct float_specs { int precision; float_format format : 8; sign_t sign : 8; - bool upper : 1; bool locale : 1; bool binary32 : 1; bool showpoint : 1; }; -template <typename ErrorHandler = error_handler, typename Char> -FMT_CONSTEXPR auto parse_float_type_spec(const format_specs<Char>& specs, - ErrorHandler&& eh = {}) +// DEPRECATED! +FMT_CONSTEXPR inline auto parse_float_type_spec(const format_specs& specs) -> float_specs { auto result = float_specs(); result.showpoint = specs.alt; result.locale = specs.localized; switch (specs.type) { - case presentation_type::none: - result.format = float_format::general; - break; - case presentation_type::general_upper: - result.upper = true; + default: FMT_FALLTHROUGH; - case presentation_type::general_lower: + case presentation_type::none: result.format = float_format::general; break; - case presentation_type::exp_upper: - result.upper = true; - FMT_FALLTHROUGH; - case presentation_type::exp_lower: + case presentation_type::exp: result.format = float_format::exp; result.showpoint |= specs.precision != 0; break; - case presentation_type::fixed_upper: - result.upper = true; - FMT_FALLTHROUGH; - case presentation_type::fixed_lower: + case presentation_type::fixed: result.format = float_format::fixed; result.showpoint |= specs.precision != 0; break; - case presentation_type::hexfloat_upper: - result.upper = true; - FMT_FALLTHROUGH; - case presentation_type::hexfloat_lower: - result.format = float_format::hex; - break; - default: - eh.on_error("invalid format specifier"); + case presentation_type::general: + result.format = float_format::general; break; } return result; @@ -2539,21 +2416,21 @@ FMT_CONSTEXPR auto parse_float_type_spec(const format_specs<Char>& specs, template <typename Char, typename OutputIt> FMT_CONSTEXPR20 auto write_nonfinite(OutputIt out, bool isnan, - format_specs<Char> specs, - const float_specs& fspecs) -> OutputIt { + format_specs specs, sign_t sign) + -> OutputIt { auto str = - isnan ? (fspecs.upper ? "NAN" : "nan") : (fspecs.upper ? "INF" : "inf"); + isnan ? (specs.upper ? "NAN" : "nan") : (specs.upper ? "INF" : "inf"); constexpr size_t str_size = 3; - auto sign = fspecs.sign; auto size = str_size + (sign ? 1 : 0); // Replace '0'-padding with space for non-finite values. const bool is_zero_fill = - specs.fill.size() == 1 && *specs.fill.data() == static_cast<Char>('0'); - if (is_zero_fill) specs.fill[0] = static_cast<Char>(' '); - return write_padded(out, specs, size, [=](reserve_iterator<OutputIt> it) { - if (sign) *it++ = detail::sign<Char>(sign); - return copy_str<Char>(str, str + str_size, it); - }); + specs.fill.size() == 1 && specs.fill.template get<Char>() == '0'; + if (is_zero_fill) specs.fill = ' '; + return write_padded<Char>(out, specs, size, + [=](reserve_iterator<OutputIt> it) { + if (sign) *it++ = detail::sign<Char>(sign); + return copy<Char>(str, str + str_size, it); + }); } // A decimal floating-point number significand * pow(10, exp). @@ -2574,7 +2451,7 @@ inline auto get_significand_size(const dragonbox::decimal_fp<T>& f) -> int { template <typename Char, typename OutputIt> constexpr auto write_significand(OutputIt out, const char* significand, int significand_size) -> OutputIt { - return copy_str<Char>(significand, significand + significand_size, out); + return copy<Char>(significand, significand + significand_size, out); } template <typename Char, typename OutputIt, typename UInt> inline auto write_significand(OutputIt out, UInt significand, @@ -2627,19 +2504,19 @@ inline auto write_significand(OutputIt out, UInt significand, Char buffer[digits10<UInt>() + 2]; auto end = write_significand(buffer, significand, significand_size, integral_size, decimal_point); - return detail::copy_str_noinline<Char>(buffer, end, out); + return detail::copy_noinline<Char>(buffer, end, out); } template <typename OutputIt, typename Char> FMT_CONSTEXPR auto write_significand(OutputIt out, const char* significand, int significand_size, int integral_size, Char decimal_point) -> OutputIt { - out = detail::copy_str_noinline<Char>(significand, - significand + integral_size, out); + out = detail::copy_noinline<Char>(significand, significand + integral_size, + out); if (!decimal_point) return out; *out++ = decimal_point; - return detail::copy_str_noinline<Char>(significand + integral_size, - significand + significand_size, out); + return detail::copy_noinline<Char>(significand + integral_size, + significand + significand_size, out); } template <typename OutputIt, typename Char, typename T, typename Grouping> @@ -2652,18 +2529,18 @@ FMT_CONSTEXPR20 auto write_significand(OutputIt out, T significand, decimal_point); } auto buffer = basic_memory_buffer<Char>(); - write_significand(buffer_appender<Char>(buffer), significand, - significand_size, integral_size, decimal_point); + write_significand(basic_appender<Char>(buffer), significand, significand_size, + integral_size, decimal_point); grouping.apply( out, basic_string_view<Char>(buffer.data(), to_unsigned(integral_size))); - return detail::copy_str_noinline<Char>(buffer.data() + integral_size, - buffer.end(), out); + return detail::copy_noinline<Char>(buffer.data() + integral_size, + buffer.end(), out); } -template <typename OutputIt, typename DecimalFP, typename Char, +template <typename Char, typename OutputIt, typename DecimalFP, typename Grouping = digit_grouping<Char>> FMT_CONSTEXPR20 auto do_write_float(OutputIt out, const DecimalFP& f, - const format_specs<Char>& specs, + const format_specs& specs, float_specs fspecs, locale_ref loc) -> OutputIt { auto significand = f.significand; @@ -2700,7 +2577,7 @@ FMT_CONSTEXPR20 auto do_write_float(OutputIt out, const DecimalFP& f, if (abs_output_exp >= 100) exp_digits = abs_output_exp >= 1000 ? 4 : 3; size += to_unsigned((decimal_point ? 1 : 0) + 2 + exp_digits); - char exp_char = fspecs.upper ? 'E' : 'e'; + char exp_char = specs.upper ? 'E' : 'e'; auto write = [=](iterator it) { if (sign) *it++ = detail::sign<Char>(sign); // Insert a decimal point after the first digit and add an exponent. @@ -2710,8 +2587,9 @@ FMT_CONSTEXPR20 auto do_write_float(OutputIt out, const DecimalFP& f, *it++ = static_cast<Char>(exp_char); return write_exponent<Char>(output_exp, it); }; - return specs.width > 0 ? write_padded<align::right>(out, specs, size, write) - : base_iterator(out, write(reserve(out, size))); + return specs.width > 0 + ? write_padded<Char, align::right>(out, specs, size, write) + : base_iterator(out, write(reserve(out, size))); } int exp = f.exponent + significand_size; @@ -2727,7 +2605,7 @@ FMT_CONSTEXPR20 auto do_write_float(OutputIt out, const DecimalFP& f, } auto grouping = Grouping(loc, fspecs.locale); size += to_unsigned(grouping.count_separators(exp)); - return write_padded<align::right>(out, specs, size, [&](iterator it) { + return write_padded<Char, align::right>(out, specs, size, [&](iterator it) { if (sign) *it++ = detail::sign<Char>(sign); it = write_significand<Char>(it, significand, significand_size, f.exponent, grouping); @@ -2741,7 +2619,7 @@ FMT_CONSTEXPR20 auto do_write_float(OutputIt out, const DecimalFP& f, size += 1 + to_unsigned(num_zeros > 0 ? num_zeros : 0); auto grouping = Grouping(loc, fspecs.locale); size += to_unsigned(grouping.count_separators(exp)); - return write_padded<align::right>(out, specs, size, [&](iterator it) { + return write_padded<Char, align::right>(out, specs, size, [&](iterator it) { if (sign) *it++ = detail::sign<Char>(sign); it = write_significand(it, significand, significand_size, exp, decimal_point, grouping); @@ -2756,7 +2634,7 @@ FMT_CONSTEXPR20 auto do_write_float(OutputIt out, const DecimalFP& f, } bool pointy = num_zeros != 0 || significand_size != 0 || fspecs.showpoint; size += 1 + (pointy ? 1 : 0) + to_unsigned(num_zeros); - return write_padded<align::right>(out, specs, size, [&](iterator it) { + return write_padded<Char, align::right>(out, specs, size, [&](iterator it) { if (sign) *it++ = detail::sign<Char>(sign); *it++ = zero; if (!pointy) return it; @@ -2770,32 +2648,31 @@ template <typename Char> class fallback_digit_grouping { public: constexpr fallback_digit_grouping(locale_ref, bool) {} - constexpr bool has_separator() const { return false; } + constexpr auto has_separator() const -> bool { return false; } - constexpr int count_separators(int) const { return 0; } + constexpr auto count_separators(int) const -> int { return 0; } template <typename Out, typename C> - constexpr Out apply(Out out, basic_string_view<C>) const { + constexpr auto apply(Out out, basic_string_view<C>) const -> Out { return out; } }; -template <typename OutputIt, typename DecimalFP, typename Char> +template <typename Char, typename OutputIt, typename DecimalFP> FMT_CONSTEXPR20 auto write_float(OutputIt out, const DecimalFP& f, - const format_specs<Char>& specs, - float_specs fspecs, locale_ref loc) - -> OutputIt { + const format_specs& specs, float_specs fspecs, + locale_ref loc) -> OutputIt { if (is_constant_evaluated()) { - return do_write_float<OutputIt, DecimalFP, Char, + return do_write_float<Char, OutputIt, DecimalFP, fallback_digit_grouping<Char>>(out, f, specs, fspecs, loc); } else { - return do_write_float(out, f, specs, fspecs, loc); + return do_write_float<Char>(out, f, specs, fspecs, loc); } } -template <typename T> constexpr bool isnan(T value) { - return !(value >= value); // std::isnan doesn't support __float128. +template <typename T> constexpr auto isnan(T value) -> bool { + return value != value; // std::isnan doesn't support __float128. } template <typename T, typename Enable = void> @@ -2807,14 +2684,14 @@ struct has_isfinite<T, enable_if_t<sizeof(std::isfinite(T())) != 0>> template <typename T, FMT_ENABLE_IF(std::is_floating_point<T>::value&& has_isfinite<T>::value)> -FMT_CONSTEXPR20 bool isfinite(T value) { +FMT_CONSTEXPR20 auto isfinite(T value) -> bool { constexpr T inf = T(std::numeric_limits<double>::infinity()); if (is_constant_evaluated()) return !detail::isnan(value) && value < inf && value > -inf; return std::isfinite(value); } template <typename T, FMT_ENABLE_IF(!has_isfinite<T>::value)> -FMT_CONSTEXPR bool isfinite(T value) { +FMT_CONSTEXPR auto isfinite(T value) -> bool { T inf = T(std::numeric_limits<double>::infinity()); // std::isfinite doesn't support __float128. return !detail::isnan(value) && value < inf && value > -inf; @@ -2833,78 +2710,6 @@ FMT_INLINE FMT_CONSTEXPR bool signbit(T value) { return std::signbit(static_cast<double>(value)); } -enum class round_direction { unknown, up, down }; - -// Given the divisor (normally a power of 10), the remainder = v % divisor for -// some number v and the error, returns whether v should be rounded up, down, or -// whether the rounding direction can't be determined due to error. -// error should be less than divisor / 2. -FMT_CONSTEXPR inline round_direction get_round_direction(uint64_t divisor, - uint64_t remainder, - uint64_t error) { - FMT_ASSERT(remainder < divisor, ""); // divisor - remainder won't overflow. - FMT_ASSERT(error < divisor, ""); // divisor - error won't overflow. - FMT_ASSERT(error < divisor - error, ""); // error * 2 won't overflow. - // Round down if (remainder + error) * 2 <= divisor. - if (remainder <= divisor - remainder && error * 2 <= divisor - remainder * 2) - return round_direction::down; - // Round up if (remainder - error) * 2 >= divisor. - if (remainder >= error && - remainder - error >= divisor - (remainder - error)) { - return round_direction::up; - } - return round_direction::unknown; -} - -namespace digits { -enum result { - more, // Generate more digits. - done, // Done generating digits. - error // Digit generation cancelled due to an error. -}; -} - -struct gen_digits_handler { - char* buf; - int size; - int precision; - int exp10; - bool fixed; - - FMT_CONSTEXPR digits::result on_digit(char digit, uint64_t divisor, - uint64_t remainder, uint64_t error, - bool integral) { - FMT_ASSERT(remainder < divisor, ""); - buf[size++] = digit; - if (!integral && error >= remainder) return digits::error; - if (size < precision) return digits::more; - if (!integral) { - // Check if error * 2 < divisor with overflow prevention. - // The check is not needed for the integral part because error = 1 - // and divisor > (1 << 32) there. - if (error >= divisor || error >= divisor - error) return digits::error; - } else { - FMT_ASSERT(error == 1 && divisor > 2, ""); - } - auto dir = get_round_direction(divisor, remainder, error); - if (dir != round_direction::up) - return dir == round_direction::down ? digits::done : digits::error; - ++buf[size - 1]; - for (int i = size - 1; i > 0 && buf[i] > '9'; --i) { - buf[i] = '0'; - ++buf[i - 1]; - } - if (buf[0] > '9') { - buf[0] = '1'; - if (fixed) - buf[size++] = '0'; - else - ++exp10; - } - return digits::done; - } -}; - inline FMT_CONSTEXPR20 void adjust_precision(int& precision, int exp10) { // Adjust fixed precision by exponent because it is relative to decimal // point. @@ -2913,101 +2718,6 @@ inline FMT_CONSTEXPR20 void adjust_precision(int& precision, int exp10) { precision += exp10; } -// Generates output using the Grisu digit-gen algorithm. -// error: the size of the region (lower, upper) outside of which numbers -// definitely do not round to value (Delta in Grisu3). -FMT_INLINE FMT_CONSTEXPR20 auto grisu_gen_digits(fp value, uint64_t error, - int& exp, - gen_digits_handler& handler) - -> digits::result { - const fp one(1ULL << -value.e, value.e); - // The integral part of scaled value (p1 in Grisu) = value / one. It cannot be - // zero because it contains a product of two 64-bit numbers with MSB set (due - // to normalization) - 1, shifted right by at most 60 bits. - auto integral = static_cast<uint32_t>(value.f >> -one.e); - FMT_ASSERT(integral != 0, ""); - FMT_ASSERT(integral == value.f >> -one.e, ""); - // The fractional part of scaled value (p2 in Grisu) c = value % one. - uint64_t fractional = value.f & (one.f - 1); - exp = count_digits(integral); // kappa in Grisu. - // Non-fixed formats require at least one digit and no precision adjustment. - if (handler.fixed) { - adjust_precision(handler.precision, exp + handler.exp10); - // Check if precision is satisfied just by leading zeros, e.g. - // format("{:.2f}", 0.001) gives "0.00" without generating any digits. - if (handler.precision <= 0) { - if (handler.precision < 0) return digits::done; - // Divide by 10 to prevent overflow. - uint64_t divisor = data::power_of_10_64[exp - 1] << -one.e; - auto dir = get_round_direction(divisor, value.f / 10, error * 10); - if (dir == round_direction::unknown) return digits::error; - handler.buf[handler.size++] = dir == round_direction::up ? '1' : '0'; - return digits::done; - } - } - // Generate digits for the integral part. This can produce up to 10 digits. - do { - uint32_t digit = 0; - auto divmod_integral = [&](uint32_t divisor) { - digit = integral / divisor; - integral %= divisor; - }; - // This optimization by Milo Yip reduces the number of integer divisions by - // one per iteration. - switch (exp) { - case 10: - divmod_integral(1000000000); - break; - case 9: - divmod_integral(100000000); - break; - case 8: - divmod_integral(10000000); - break; - case 7: - divmod_integral(1000000); - break; - case 6: - divmod_integral(100000); - break; - case 5: - divmod_integral(10000); - break; - case 4: - divmod_integral(1000); - break; - case 3: - divmod_integral(100); - break; - case 2: - divmod_integral(10); - break; - case 1: - digit = integral; - integral = 0; - break; - default: - FMT_ASSERT(false, "invalid number of digits"); - } - --exp; - auto remainder = (static_cast<uint64_t>(integral) << -one.e) + fractional; - auto result = handler.on_digit(static_cast<char>('0' + digit), - data::power_of_10_64[exp] << -one.e, - remainder, error, true); - if (result != digits::more) return result; - } while (exp > 0); - // Generate digits for the fractional part. - for (;;) { - fractional *= 10; - error *= 10; - char digit = static_cast<char>('0' + (fractional >> -one.e)); - fractional &= one.f - 1; - --exp; - auto result = handler.on_digit(digit, one.f, fractional, error, false); - if (result != digits::more) return result; - } -} - class bigint { private: // A bigint is stored as an array of bigits (big digits), with bigit at index @@ -3018,10 +2728,10 @@ class bigint { basic_memory_buffer<bigit, bigits_capacity> bigits_; int exp_; - FMT_CONSTEXPR20 bigit operator[](int index) const { + FMT_CONSTEXPR20 auto operator[](int index) const -> bigit { return bigits_[to_unsigned(index)]; } - FMT_CONSTEXPR20 bigit& operator[](int index) { + FMT_CONSTEXPR20 auto operator[](int index) -> bigit& { return bigits_[to_unsigned(index)]; } @@ -3108,7 +2818,7 @@ class bigint { auto size = other.bigits_.size(); bigits_.resize(size); auto data = other.bigits_.data(); - std::copy(data, data + size, make_checked(bigits_.data(), size)); + copy<bigit>(data, data + size, bigits_.data()); exp_ = other.exp_; } @@ -3117,11 +2827,11 @@ class bigint { assign(uint64_or_128_t<Int>(n)); } - FMT_CONSTEXPR20 int num_bigits() const { + FMT_CONSTEXPR20 auto num_bigits() const -> int { return static_cast<int>(bigits_.size()) + exp_; } - FMT_NOINLINE FMT_CONSTEXPR20 bigint& operator<<=(int shift) { + FMT_NOINLINE FMT_CONSTEXPR20 auto operator<<=(int shift) -> bigint& { FMT_ASSERT(shift >= 0, ""); exp_ += shift / bigit_bits; shift %= bigit_bits; @@ -3136,13 +2846,15 @@ class bigint { return *this; } - template <typename Int> FMT_CONSTEXPR20 bigint& operator*=(Int value) { + template <typename Int> + FMT_CONSTEXPR20 auto operator*=(Int value) -> bigint& { FMT_ASSERT(value > 0, ""); multiply(uint32_or_64_or_128_t<Int>(value)); return *this; } - friend FMT_CONSTEXPR20 int compare(const bigint& lhs, const bigint& rhs) { + friend FMT_CONSTEXPR20 auto compare(const bigint& lhs, const bigint& rhs) + -> int { int num_lhs_bigits = lhs.num_bigits(), num_rhs_bigits = rhs.num_bigits(); if (num_lhs_bigits != num_rhs_bigits) return num_lhs_bigits > num_rhs_bigits ? 1 : -1; @@ -3159,8 +2871,9 @@ class bigint { } // Returns compare(lhs1 + lhs2, rhs). - friend FMT_CONSTEXPR20 int add_compare(const bigint& lhs1, const bigint& lhs2, - const bigint& rhs) { + friend FMT_CONSTEXPR20 auto add_compare(const bigint& lhs1, + const bigint& lhs2, const bigint& rhs) + -> int { auto minimum = [](int a, int b) { return a < b ? a : b; }; auto maximum = [](int a, int b) { return a > b ? a : b; }; int max_lhs_bigits = maximum(lhs1.num_bigits(), lhs2.num_bigits()); @@ -3241,13 +2954,13 @@ class bigint { bigits_.resize(to_unsigned(num_bigits + exp_difference)); for (int i = num_bigits - 1, j = i + exp_difference; i >= 0; --i, --j) bigits_[j] = bigits_[i]; - std::uninitialized_fill_n(bigits_.data(), exp_difference, 0); + memset(bigits_.data(), 0, to_unsigned(exp_difference) * sizeof(bigit)); exp_ -= exp_difference; } // Divides this bignum by divisor, assigning the remainder to this and // returning the quotient. - FMT_CONSTEXPR20 int divmod_assign(const bigint& divisor) { + FMT_CONSTEXPR20 auto divmod_assign(const bigint& divisor) -> int { FMT_ASSERT(this != &divisor, ""); if (compare(*this, divisor) < 0) return 0; FMT_ASSERT(divisor.bigits_[divisor.bigits_.size() - 1u] != 0, ""); @@ -3322,6 +3035,7 @@ FMT_CONSTEXPR20 inline void format_dragon(basic_fp<uint128_t> value, } int even = static_cast<int>((value.f & 1) == 0); if (!upper) upper = &lower; + bool shortest = num_digits < 0; if ((flags & dragon::fixup) != 0) { if (add_compare(numerator, *upper, denominator) + even <= 0) { --exp10; @@ -3334,7 +3048,7 @@ FMT_CONSTEXPR20 inline void format_dragon(basic_fp<uint128_t> value, if ((flags & dragon::fixed) != 0) adjust_precision(num_digits, exp10 + 1); } // Invariant: value == (numerator / denominator) * pow(10, exp10). - if (num_digits < 0) { + if (shortest) { // Generate the shortest representation. num_digits = 0; char* data = buf.data(); @@ -3364,9 +3078,12 @@ FMT_CONSTEXPR20 inline void format_dragon(basic_fp<uint128_t> value, } // Generate the given number of digits. exp10 -= num_digits - 1; - if (num_digits == 0) { - denominator *= 10; - auto digit = add_compare(numerator, numerator, denominator) > 0 ? '1' : '0'; + if (num_digits <= 0) { + auto digit = '0'; + if (num_digits == 0) { + denominator *= 10; + digit = add_compare(numerator, numerator, denominator) > 0 ? '1' : '0'; + } buf.push_back(digit); return; } @@ -3389,7 +3106,10 @@ FMT_CONSTEXPR20 inline void format_dragon(basic_fp<uint128_t> value, } if (buf[0] == overflow) { buf[0] = '1'; - ++exp10; + if ((flags & dragon::fixed) != 0) + buf.push_back('0'); + else + ++exp10; } return; } @@ -3400,8 +3120,8 @@ FMT_CONSTEXPR20 inline void format_dragon(basic_fp<uint128_t> value, // Formats a floating-point number using the hexfloat format. template <typename Float, FMT_ENABLE_IF(!is_double_double<Float>::value)> -FMT_CONSTEXPR20 void format_hexfloat(Float value, int precision, - float_specs specs, buffer<char>& buf) { +FMT_CONSTEXPR20 void format_hexfloat(Float value, format_specs specs, + buffer<char>& buf) { // float is passed as double to reduce the number of instantiations and to // simplify implementation. static_assert(!std::is_same<Float, float>::value, ""); @@ -3429,8 +3149,8 @@ FMT_CONSTEXPR20 void format_hexfloat(Float value, int precision, if (leading_xdigit > 1) f.e -= (32 - countl_zero(leading_xdigit) - 1); int print_xdigits = num_xdigits - 1; - if (precision >= 0 && print_xdigits > precision) { - const int shift = ((print_xdigits - precision - 1) * 4); + if (specs.precision >= 0 && print_xdigits > specs.precision) { + const int shift = ((print_xdigits - specs.precision - 1) * 4); const auto mask = carrier_uint(0xF) << shift; const auto v = static_cast<uint32_t>((f.f & mask) >> shift); @@ -3449,7 +3169,7 @@ FMT_CONSTEXPR20 void format_hexfloat(Float value, int precision, } } - print_xdigits = precision; + print_xdigits = specs.precision; } char xdigits[num_bits<carrier_uint>() / 4]; @@ -3462,10 +3182,10 @@ FMT_CONSTEXPR20 void format_hexfloat(Float value, int precision, buf.push_back('0'); buf.push_back(specs.upper ? 'X' : 'x'); buf.push_back(xdigits[0]); - if (specs.showpoint || print_xdigits > 0 || print_xdigits < precision) + if (specs.alt || print_xdigits > 0 || print_xdigits < specs.precision) buf.push_back('.'); buf.append(xdigits + 1, xdigits + 1 + print_xdigits); - for (; print_xdigits < precision; ++print_xdigits) buf.push_back('0'); + for (; print_xdigits < specs.precision; ++print_xdigits) buf.push_back('0'); buf.push_back(specs.upper ? 'P' : 'p'); @@ -3481,9 +3201,20 @@ FMT_CONSTEXPR20 void format_hexfloat(Float value, int precision, } template <typename Float, FMT_ENABLE_IF(is_double_double<Float>::value)> -FMT_CONSTEXPR20 void format_hexfloat(Float value, int precision, - float_specs specs, buffer<char>& buf) { - format_hexfloat(static_cast<double>(value), precision, specs, buf); +FMT_CONSTEXPR20 void format_hexfloat(Float value, format_specs specs, + buffer<char>& buf) { + format_hexfloat(static_cast<double>(value), specs, buf); +} + +constexpr auto fractional_part_rounding_thresholds(int index) -> uint32_t { + // For checking rounding thresholds. + // The kth entry is chosen to be the smallest integer such that the + // upper 32-bits of 10^(k+1) times it is strictly bigger than 5 * 10^k. + // It is equal to ceil(2^31 + 2^32/10^(k + 1)). + // These are stored in a string literal because we cannot have static arrays + // in constexpr functions and non-static ones are poorly optimized. + return U"\x9999999a\x828f5c29\x80418938\x80068db9\x8000a7c6\x800010c7" + U"\x800001ae\x8000002b"[index]; } template <typename Float> @@ -3508,7 +3239,7 @@ FMT_CONSTEXPR20 auto format_float(Float value, int precision, float_specs specs, int exp = 0; bool use_dragon = true; unsigned dragon_flags = 0; - if (!is_fast_float<Float>()) { + if (!is_fast_float<Float>() || is_constant_evaluated()) { const auto inv_log2_10 = 0.3010299956639812; // 1 / log2(10) using info = dragonbox::float_info<decltype(converted_value)>; const auto f = basic_fp<typename info::carrier_uint>(converted_value); @@ -3516,38 +3247,20 @@ FMT_CONSTEXPR20 auto format_float(Float value, int precision, float_specs specs, // 10^(exp - 1) <= value < 10^exp or 10^exp <= value < 10^(exp + 1). // This is based on log10(value) == log2(value) / log2(10) and approximation // of log2(value) by e + num_fraction_bits idea from double-conversion. - exp = static_cast<int>( - std::ceil((f.e + count_digits<1>(f.f) - 1) * inv_log2_10 - 1e-10)); + auto e = (f.e + count_digits<1>(f.f) - 1) * inv_log2_10 - 1e-10; + exp = static_cast<int>(e); + if (e > exp) ++exp; // Compute ceil. dragon_flags = dragon::fixup; - } else if (!is_constant_evaluated() && precision < 0) { + } else if (precision < 0) { // Use Dragonbox for the shortest format. if (specs.binary32) { auto dec = dragonbox::to_decimal(static_cast<float>(value)); - write<char>(buffer_appender<char>(buf), dec.significand); + write<char>(appender(buf), dec.significand); return dec.exponent; } auto dec = dragonbox::to_decimal(static_cast<double>(value)); - write<char>(buffer_appender<char>(buf), dec.significand); + write<char>(appender(buf), dec.significand); return dec.exponent; - } else if (is_constant_evaluated()) { - // Use Grisu + Dragon4 for the given precision: - // https://www.cs.tufts.edu/~nr/cs257/archive/florian-loitsch/printf.pdf. - const int min_exp = -60; // alpha in Grisu. - int cached_exp10 = 0; // K in Grisu. - fp normalized = normalize(fp(converted_value)); - const auto cached_pow = get_cached_power( - min_exp - (normalized.e + fp::num_significand_bits), cached_exp10); - normalized = normalized * cached_pow; - gen_digits_handler handler{buf.data(), 0, precision, -cached_exp10, fixed}; - if (grisu_gen_digits(normalized, 1, exp, handler) != digits::error && - !is_constant_evaluated()) { - exp += handler.exp10; - buf.try_resize(to_unsigned(handler.size)); - use_dragon = false; - } else { - exp += handler.size - cached_exp10 - 1; - precision = handler.precision; - } } else { // Extract significand bits and exponent bits. using info = dragonbox::float_info<double>; @@ -3566,7 +3279,7 @@ FMT_CONSTEXPR20 auto format_float(Float value, int precision, float_specs specs, significand <<= 1; } else { // Normalize subnormal inputs. - FMT_ASSERT(significand != 0, "zeros should not appear hear"); + FMT_ASSERT(significand != 0, "zeros should not appear here"); int shift = countl_zero(significand); FMT_ASSERT(shift >= num_bits<uint64_t>() - num_significand_bits<double>(), ""); @@ -3603,9 +3316,7 @@ FMT_CONSTEXPR20 auto format_float(Float value, int precision, float_specs specs, } // Compute the actual number of decimal digits to print. - if (fixed) { - adjust_precision(precision, exp + digits_in_the_first_segment); - } + if (fixed) adjust_precision(precision, exp + digits_in_the_first_segment); // Use Dragon4 only when there might be not enough digits in the first // segment. @@ -3710,12 +3421,12 @@ FMT_CONSTEXPR20 auto format_float(Float value, int precision, float_specs specs, // fractional part is strictly larger than 1/2. if (precision < 9) { uint32_t fractional_part = static_cast<uint32_t>(prod); - should_round_up = fractional_part >= - data::fractional_part_rounding_thresholds - [8 - number_of_digits_to_print] || - ((fractional_part >> 31) & - ((digits & 1) | (second_third_subsegments != 0) | - has_more_segments)) != 0; + should_round_up = + fractional_part >= fractional_part_rounding_thresholds( + 8 - number_of_digits_to_print) || + ((fractional_part >> 31) & + ((digits & 1) | (second_third_subsegments != 0) | + has_more_segments)) != 0; } // Rounding at the subsegment boundary. // In this case, the fractional part is at least 1/2 if and only if @@ -3750,12 +3461,12 @@ FMT_CONSTEXPR20 auto format_float(Float value, int precision, float_specs specs, // of 19 digits, so in this case the third segment should be // consisting of a genuine digit from the input. uint32_t fractional_part = static_cast<uint32_t>(prod); - should_round_up = fractional_part >= - data::fractional_part_rounding_thresholds - [8 - number_of_digits_to_print] || - ((fractional_part >> 31) & - ((digits & 1) | (third_subsegment != 0) | - has_more_segments)) != 0; + should_round_up = + fractional_part >= fractional_part_rounding_thresholds( + 8 - number_of_digits_to_print) || + ((fractional_part >> 31) & + ((digits & 1) | (third_subsegment != 0) | + has_more_segments)) != 0; } // Rounding at the subsegment boundary. else { @@ -3815,97 +3526,101 @@ FMT_CONSTEXPR20 auto format_float(Float value, int precision, float_specs specs, } return exp; } + template <typename Char, typename OutputIt, typename T> -FMT_CONSTEXPR20 auto write_float(OutputIt out, T value, - format_specs<Char> specs, locale_ref loc) - -> OutputIt { - float_specs fspecs = parse_float_type_spec(specs); - fspecs.sign = specs.sign; +FMT_CONSTEXPR20 auto write_float(OutputIt out, T value, format_specs specs, + locale_ref loc) -> OutputIt { + sign_t sign = specs.sign; if (detail::signbit(value)) { // value < 0 is false for NaN so use signbit. - fspecs.sign = sign::minus; + sign = sign::minus; value = -value; - } else if (fspecs.sign == sign::minus) { - fspecs.sign = sign::none; + } else if (sign == sign::minus) { + sign = sign::none; } if (!detail::isfinite(value)) - return write_nonfinite(out, detail::isnan(value), specs, fspecs); + return write_nonfinite<Char>(out, detail::isnan(value), specs, sign); - if (specs.align == align::numeric && fspecs.sign) { + if (specs.align == align::numeric && sign) { auto it = reserve(out, 1); - *it++ = detail::sign<Char>(fspecs.sign); + *it++ = detail::sign<Char>(sign); out = base_iterator(out, it); - fspecs.sign = sign::none; + sign = sign::none; if (specs.width != 0) --specs.width; } memory_buffer buffer; - if (fspecs.format == float_format::hex) { - if (fspecs.sign) buffer.push_back(detail::sign<char>(fspecs.sign)); - format_hexfloat(convert_float(value), specs.precision, fspecs, buffer); - return write_bytes<align::right>(out, {buffer.data(), buffer.size()}, - specs); + if (specs.type == presentation_type::hexfloat) { + if (sign) buffer.push_back(detail::sign<char>(sign)); + format_hexfloat(convert_float(value), specs, buffer); + return write_bytes<Char, align::right>(out, {buffer.data(), buffer.size()}, + specs); } + int precision = specs.precision >= 0 || specs.type == presentation_type::none ? specs.precision : 6; - if (fspecs.format == float_format::exp) { + if (specs.type == presentation_type::exp) { if (precision == max_value<int>()) - throw_format_error("number is too big"); + report_error("number is too big"); else ++precision; - } else if (fspecs.format != float_format::fixed && precision == 0) { + } else if (specs.type != presentation_type::fixed && precision == 0) { precision = 1; } + float_specs fspecs = parse_float_type_spec(specs); + fspecs.sign = sign; if (const_check(std::is_same<T, float>())) fspecs.binary32 = true; int exp = format_float(convert_float(value), precision, fspecs, buffer); fspecs.precision = precision; auto f = big_decimal_fp{buffer.data(), static_cast<int>(buffer.size()), exp}; - return write_float(out, f, specs, fspecs, loc); + return write_float<Char>(out, f, specs, fspecs, loc); } template <typename Char, typename OutputIt, typename T, FMT_ENABLE_IF(is_floating_point<T>::value)> -FMT_CONSTEXPR20 auto write(OutputIt out, T value, format_specs<Char> specs, +FMT_CONSTEXPR20 auto write(OutputIt out, T value, format_specs specs, locale_ref loc = {}) -> OutputIt { if (const_check(!is_supported_floating_point(value))) return out; return specs.localized && write_loc(out, value, specs, loc) ? out - : write_float(out, value, specs, loc); + : write_float<Char>(out, value, specs, loc); } template <typename Char, typename OutputIt, typename T, FMT_ENABLE_IF(is_fast_float<T>::value)> FMT_CONSTEXPR20 auto write(OutputIt out, T value) -> OutputIt { - if (is_constant_evaluated()) return write(out, value, format_specs<Char>()); + if (is_constant_evaluated()) return write<Char>(out, value, format_specs()); if (const_check(!is_supported_floating_point(value))) return out; - auto fspecs = float_specs(); + auto sign = sign_t::none; if (detail::signbit(value)) { - fspecs.sign = sign::minus; + sign = sign::minus; value = -value; } - constexpr auto specs = format_specs<Char>(); + constexpr auto specs = format_specs(); using floaty = conditional_t<std::is_same<T, long double>::value, double, T>; using floaty_uint = typename dragonbox::float_info<floaty>::carrier_uint; floaty_uint mask = exponent_mask<floaty>(); if ((bit_cast<floaty_uint>(value) & mask) == mask) - return write_nonfinite(out, std::isnan(value), specs, fspecs); + return write_nonfinite<Char>(out, std::isnan(value), specs, sign); + auto fspecs = float_specs(); + fspecs.sign = sign; auto dec = dragonbox::to_decimal(static_cast<floaty>(value)); - return write_float(out, dec, specs, fspecs, {}); + return write_float<Char>(out, dec, specs, fspecs, {}); } template <typename Char, typename OutputIt, typename T, FMT_ENABLE_IF(is_floating_point<T>::value && !is_fast_float<T>::value)> inline auto write(OutputIt out, T value) -> OutputIt { - return write(out, value, format_specs<Char>()); + return write<Char>(out, value, format_specs()); } template <typename Char, typename OutputIt> -auto write(OutputIt out, monostate, format_specs<Char> = {}, locale_ref = {}) +auto write(OutputIt out, monostate, format_specs = {}, locale_ref = {}) -> OutputIt { FMT_ASSERT(false, ""); return out; @@ -3915,12 +3630,12 @@ template <typename Char, typename OutputIt> FMT_CONSTEXPR auto write(OutputIt out, basic_string_view<Char> value) -> OutputIt { auto it = reserve(out, value.size()); - it = copy_str_noinline<Char>(value.begin(), value.end(), it); + it = copy_noinline<Char>(value.begin(), value.end(), it); return base_iterator(out, it); } template <typename Char, typename OutputIt, typename T, - FMT_ENABLE_IF(is_string<T>::value)> + FMT_ENABLE_IF(has_to_string_view<T>::value)> constexpr auto write(OutputIt out, const T& value) -> OutputIt { return write<Char>(out, to_string_view(value)); } @@ -3939,13 +3654,12 @@ FMT_CONSTEXPR auto write(OutputIt out, T value) -> OutputIt { template <typename Char, typename OutputIt, typename T, FMT_ENABLE_IF(std::is_same<T, bool>::value)> -FMT_CONSTEXPR auto write(OutputIt out, T value, - const format_specs<Char>& specs = {}, locale_ref = {}) - -> OutputIt { +FMT_CONSTEXPR auto write(OutputIt out, T value, const format_specs& specs = {}, + locale_ref = {}) -> OutputIt { return specs.type != presentation_type::none && specs.type != presentation_type::string - ? write(out, value ? 1 : 0, specs, {}) - : write_bytes(out, value ? "true" : "false", specs); + ? write<Char>(out, value ? 1 : 0, specs, {}) + : write_bytes<Char>(out, value ? "true" : "false", specs); } template <typename Char, typename OutputIt> @@ -3956,16 +3670,15 @@ FMT_CONSTEXPR auto write(OutputIt out, Char value) -> OutputIt { } template <typename Char, typename OutputIt> -FMT_CONSTEXPR_CHAR_TRAITS auto write(OutputIt out, const Char* value) - -> OutputIt { +FMT_CONSTEXPR20 auto write(OutputIt out, const Char* value) -> OutputIt { if (value) return write(out, basic_string_view<Char>(value)); - throw_format_error("string pointer is null"); + report_error("string pointer is null"); return out; } template <typename Char, typename OutputIt, typename T, FMT_ENABLE_IF(std::is_same<T, void>::value)> -auto write(OutputIt out, const T* value, const format_specs<Char>& specs = {}, +auto write(OutputIt out, const T* value, const format_specs& specs = {}, locale_ref = {}) -> OutputIt { return write_ptr<Char>(out, bit_cast<uintptr_t>(value), &specs); } @@ -3974,7 +3687,7 @@ auto write(OutputIt out, const T* value, const format_specs<Char>& specs = {}, template <typename Char, typename OutputIt, typename T, typename Context = basic_format_context<OutputIt, Char>> FMT_CONSTEXPR auto write(OutputIt out, const T& value) -> enable_if_t< - std::is_class<T>::value && !is_string<T>::value && + std::is_class<T>::value && !has_to_string_view<T>::value && !is_floating_point<T>::value && !std::is_same<T, Char>::value && !std::is_same<T, remove_cvref_t<decltype(arg_mapper<Context>().map( value))>>::value, @@ -3985,17 +3698,22 @@ FMT_CONSTEXPR auto write(OutputIt out, const T& value) -> enable_if_t< template <typename Char, typename OutputIt, typename T, typename Context = basic_format_context<OutputIt, Char>> FMT_CONSTEXPR auto write(OutputIt out, const T& value) - -> enable_if_t<mapped_type_constant<T, Context>::value == type::custom_type, + -> enable_if_t<mapped_type_constant<T, Context>::value == + type::custom_type && + !std::is_fundamental<T>::value, OutputIt> { + auto formatter = typename Context::template formatter_type<T>(); + auto parse_ctx = typename Context::parse_context_type({}); + formatter.parse(parse_ctx); auto ctx = Context(out, {}, {}); - return typename Context::template formatter_type<T>().format(value, ctx); + return formatter.format(value, ctx); } // An argument visitor that formats the argument and writes it via the output // iterator. It's a class and not a generic lambda for compatibility with C++11. template <typename Char> struct default_arg_formatter { - using iterator = buffer_appender<Char>; - using context = buffer_context<Char>; + using iterator = basic_appender<Char>; + using context = buffered_context<Char>; iterator out; basic_format_args<context> args; @@ -4013,16 +3731,16 @@ template <typename Char> struct default_arg_formatter { }; template <typename Char> struct arg_formatter { - using iterator = buffer_appender<Char>; - using context = buffer_context<Char>; + using iterator = basic_appender<Char>; + using context = buffered_context<Char>; iterator out; - const format_specs<Char>& specs; + const format_specs& specs; locale_ref locale; template <typename T> FMT_CONSTEXPR FMT_INLINE auto operator()(T value) -> iterator { - return detail::write(out, value, specs, locale); + return detail::write<Char>(out, value, specs, locale); } auto operator()(typename basic_format_arg<context>::handle) -> iterator { // User-defined types are handled separately because they require access @@ -4031,74 +3749,49 @@ template <typename Char> struct arg_formatter { } }; -template <typename Char> struct custom_formatter { - basic_format_parse_context<Char>& parse_ctx; - buffer_context<Char>& ctx; - - void operator()( - typename basic_format_arg<buffer_context<Char>>::handle h) const { - h.format(parse_ctx, ctx); - } - template <typename T> void operator()(T) const {} -}; - -template <typename ErrorHandler> class width_checker { - public: - explicit FMT_CONSTEXPR width_checker(ErrorHandler& eh) : handler_(eh) {} - +struct width_checker { template <typename T, FMT_ENABLE_IF(is_integer<T>::value)> FMT_CONSTEXPR auto operator()(T value) -> unsigned long long { - if (is_negative(value)) handler_.on_error("negative width"); + if (is_negative(value)) report_error("negative width"); return static_cast<unsigned long long>(value); } template <typename T, FMT_ENABLE_IF(!is_integer<T>::value)> FMT_CONSTEXPR auto operator()(T) -> unsigned long long { - handler_.on_error("width is not integer"); + report_error("width is not integer"); return 0; } - - private: - ErrorHandler& handler_; }; -template <typename ErrorHandler> class precision_checker { - public: - explicit FMT_CONSTEXPR precision_checker(ErrorHandler& eh) : handler_(eh) {} - +struct precision_checker { template <typename T, FMT_ENABLE_IF(is_integer<T>::value)> FMT_CONSTEXPR auto operator()(T value) -> unsigned long long { - if (is_negative(value)) handler_.on_error("negative precision"); + if (is_negative(value)) report_error("negative precision"); return static_cast<unsigned long long>(value); } template <typename T, FMT_ENABLE_IF(!is_integer<T>::value)> FMT_CONSTEXPR auto operator()(T) -> unsigned long long { - handler_.on_error("precision is not integer"); + report_error("precision is not integer"); return 0; } - - private: - ErrorHandler& handler_; }; -template <template <typename> class Handler, typename FormatArg, - typename ErrorHandler> -FMT_CONSTEXPR auto get_dynamic_spec(FormatArg arg, ErrorHandler eh) -> int { - unsigned long long value = visit_format_arg(Handler<ErrorHandler>(eh), arg); - if (value > to_unsigned(max_value<int>())) eh.on_error("number is too big"); +template <typename Handler, typename FormatArg> +FMT_CONSTEXPR auto get_dynamic_spec(FormatArg arg) -> int { + unsigned long long value = arg.visit(Handler()); + if (value > to_unsigned(max_value<int>())) report_error("number is too big"); return static_cast<int>(value); } template <typename Context, typename ID> -FMT_CONSTEXPR auto get_arg(Context& ctx, ID id) -> - typename Context::format_arg { +FMT_CONSTEXPR auto get_arg(Context& ctx, ID id) -> decltype(ctx.arg(id)) { auto arg = ctx.arg(id); - if (!arg) ctx.on_error("argument not found"); + if (!arg) report_error("argument not found"); return arg; } -template <template <typename> class Handler, typename Context> +template <typename Handler, typename Context> FMT_CONSTEXPR void handle_dynamic_spec(int& value, arg_ref<typename Context::char_type> ref, Context& ctx) { @@ -4106,26 +3799,15 @@ FMT_CONSTEXPR void handle_dynamic_spec(int& value, case arg_id_kind::none: break; case arg_id_kind::index: - value = detail::get_dynamic_spec<Handler>(get_arg(ctx, ref.val.index), - ctx.error_handler()); + value = detail::get_dynamic_spec<Handler>(get_arg(ctx, ref.val.index)); break; case arg_id_kind::name: - value = detail::get_dynamic_spec<Handler>(get_arg(ctx, ref.val.name), - ctx.error_handler()); + value = detail::get_dynamic_spec<Handler>(get_arg(ctx, ref.val.name)); break; } } #if FMT_USE_USER_DEFINED_LITERALS -template <typename Char> struct udl_formatter { - basic_string_view<Char> str; - - template <typename... T> - auto operator()(T&&... args) const -> std::basic_string<Char> { - return vformat(str, fmt::make_format_args<buffer_context<Char>>(args...)); - } -}; - # if FMT_USE_NONTYPE_TEMPLATE_ARGS template <typename T, typename Char, size_t N, fmt::detail_exported::fixed_string<Char, N> Str> @@ -4165,7 +3847,7 @@ template <typename Char> struct udl_arg { template <typename Locale, typename Char> auto vformat(const Locale& loc, basic_string_view<Char> fmt, - basic_format_args<buffer_context<type_identity_t<Char>>> args) + typename detail::vformat_args<Char>::type args) -> std::basic_string<Char> { auto buf = basic_memory_buffer<Char>(); detail::vformat_to(buf, fmt, args, detail::locale_ref(loc)); @@ -4177,30 +3859,30 @@ using format_func = void (*)(detail::buffer<char>&, int, const char*); FMT_API void format_error_code(buffer<char>& out, int error_code, string_view message) noexcept; +using fmt::report_error; FMT_API void report_error(format_func func, int error_code, const char* message) noexcept; -FMT_END_DETAIL_NAMESPACE +} // namespace detail +FMT_BEGIN_EXPORT FMT_API auto vsystem_error(int error_code, string_view format_str, format_args args) -> std::system_error; /** - \rst - Constructs :class:`std::system_error` with a message formatted with - ``fmt::format(fmt, args...)``. - *error_code* is a system error code as given by ``errno``. - - **Example**:: - - // This throws std::system_error with the description - // cannot open file 'madeup': No such file or directory - // or similar (system message may vary). - const char* filename = "madeup"; - std::FILE* file = std::fopen(filename, "r"); - if (!file) - throw fmt::system_error(errno, "cannot open file '{}'", filename); - \endrst -*/ + * Constructs `std::system_error` with a message formatted with + * `fmt::format(fmt, args...)`. + * `error_code` is a system error code as given by `errno`. + * + * **Example**: + * + * // This throws std::system_error with the description + * // cannot open file 'madeup': No such file or directory + * // or similar (system message may vary). + * const char* filename = "madeup"; + * std::FILE* file = std::fopen(filename, "r"); + * if (!file) + * throw fmt::system_error(errno, "cannot open file '{}'", filename); + */ template <typename... T> auto system_error(int error_code, format_string<T...> fmt, T&&... args) -> std::system_error { @@ -4208,20 +3890,17 @@ auto system_error(int error_code, format_string<T...> fmt, T&&... args) } /** - \rst - Formats an error message for an error returned by an operating system or a - language runtime, for example a file opening error, and writes it to *out*. - The format is the same as the one used by ``std::system_error(ec, message)`` - where ``ec`` is ``std::error_code(error_code, std::generic_category()})``. - It is implementation-defined but normally looks like: - - .. parsed-literal:: - *<message>*: *<system-message>* - - where *<message>* is the passed message and *<system-message>* is the system - message corresponding to the error code. - *error_code* is a system error code as given by ``errno``. - \endrst + * Formats an error message for an error returned by an operating system or a + * language runtime, for example a file opening error, and writes it to `out`. + * The format is the same as the one used by `std::system_error(ec, message)` + * where `ec` is `std::error_code(error_code, std::generic_category())`. + * It is implementation-defined but normally looks like: + * + * <message>: <system-message> + * + * where `<message>` is the passed message and `<system-message>` is the system + * message corresponding to the error code. + * `error_code` is a system error code as given by `errno`. */ FMT_API void format_system_error(detail::buffer<char>& out, int error_code, const char* message) noexcept; @@ -4230,7 +3909,7 @@ FMT_API void format_system_error(detail::buffer<char>& out, int error_code, // Can be used to report errors from destructors. FMT_API void report_system_error(int error_code, const char* message) noexcept; -/** Fast integer formatter. */ +/// A fast integer formatter. class format_int { private: // Buffer should be large enough to hold all digits (digits10 + 1), @@ -4239,12 +3918,14 @@ class format_int { mutable char buffer_[buffer_size]; char* str_; - template <typename UInt> auto format_unsigned(UInt value) -> char* { + template <typename UInt> + FMT_CONSTEXPR20 auto format_unsigned(UInt value) -> char* { auto n = static_cast<detail::uint32_or_64_or_128_t<UInt>>(value); return detail::format_decimal(buffer_, n, buffer_size - 1).begin; } - template <typename Int> auto format_signed(Int value) -> char* { + template <typename Int> + FMT_CONSTEXPR20 auto format_signed(Int value) -> char* { auto abs_value = static_cast<detail::uint32_or_64_or_128_t<Int>>(value); bool negative = value < 0; if (negative) abs_value = 0 - abs_value; @@ -4254,101 +3935,90 @@ class format_int { } public: - explicit format_int(int value) : str_(format_signed(value)) {} - explicit format_int(long value) : str_(format_signed(value)) {} - explicit format_int(long long value) : str_(format_signed(value)) {} - explicit format_int(unsigned value) : str_(format_unsigned(value)) {} - explicit format_int(unsigned long value) : str_(format_unsigned(value)) {} - explicit format_int(unsigned long long value) + explicit FMT_CONSTEXPR20 format_int(int value) : str_(format_signed(value)) {} + explicit FMT_CONSTEXPR20 format_int(long value) + : str_(format_signed(value)) {} + explicit FMT_CONSTEXPR20 format_int(long long value) + : str_(format_signed(value)) {} + explicit FMT_CONSTEXPR20 format_int(unsigned value) + : str_(format_unsigned(value)) {} + explicit FMT_CONSTEXPR20 format_int(unsigned long value) + : str_(format_unsigned(value)) {} + explicit FMT_CONSTEXPR20 format_int(unsigned long long value) : str_(format_unsigned(value)) {} - /** Returns the number of characters written to the output buffer. */ - auto size() const -> size_t { + /// Returns the number of characters written to the output buffer. + FMT_CONSTEXPR20 auto size() const -> size_t { return detail::to_unsigned(buffer_ - str_ + buffer_size - 1); } - /** - Returns a pointer to the output buffer content. No terminating null - character is appended. - */ - auto data() const -> const char* { return str_; } + /// Returns a pointer to the output buffer content. No terminating null + /// character is appended. + FMT_CONSTEXPR20 auto data() const -> const char* { return str_; } - /** - Returns a pointer to the output buffer content with terminating null - character appended. - */ - auto c_str() const -> const char* { + /// Returns a pointer to the output buffer content with terminating null + /// character appended. + FMT_CONSTEXPR20 auto c_str() const -> const char* { buffer_[buffer_size - 1] = '\0'; return str_; } - /** - \rst - Returns the content of the output buffer as an ``std::string``. - \endrst - */ + /// Returns the content of the output buffer as an `std::string`. auto str() const -> std::string { return std::string(str_, size()); } }; template <typename T, typename Char> struct formatter<T, Char, enable_if_t<detail::has_format_as<T>::value>> - : private formatter<detail::format_as_t<T>> { - using base = formatter<detail::format_as_t<T>>; - using base::parse; - + : formatter<detail::format_as_t<T>, Char> { template <typename FormatContext> auto format(const T& value, FormatContext& ctx) const -> decltype(ctx.out()) { - return base::format(format_as(value), ctx); + using base = formatter<detail::format_as_t<T>, Char>; + auto&& val = format_as(value); // Make an lvalue reference for format. + return base::format(val, ctx); } }; -template <typename Char> -struct formatter<void*, Char> : formatter<const void*, Char> { - template <typename FormatContext> - auto format(void* val, FormatContext& ctx) const -> decltype(ctx.out()) { - return formatter<const void*, Char>::format(val, ctx); - } -}; +#define FMT_FORMAT_AS(Type, Base) \ + template <typename Char> \ + struct formatter<Type, Char> : formatter<Base, Char> {} + +FMT_FORMAT_AS(signed char, int); +FMT_FORMAT_AS(unsigned char, unsigned); +FMT_FORMAT_AS(short, int); +FMT_FORMAT_AS(unsigned short, unsigned); +FMT_FORMAT_AS(long, detail::long_type); +FMT_FORMAT_AS(unsigned long, detail::ulong_type); +FMT_FORMAT_AS(Char*, const Char*); +FMT_FORMAT_AS(std::nullptr_t, const void*); +FMT_FORMAT_AS(detail::std_string_view<Char>, basic_string_view<Char>); +FMT_FORMAT_AS(void*, const void*); + +template <typename Char, typename Traits, typename Allocator> +class formatter<std::basic_string<Char, Traits, Allocator>, Char> + : public formatter<basic_string_view<Char>, Char> {}; template <typename Char, size_t N> -struct formatter<Char[N], Char> : formatter<basic_string_view<Char>, Char> { - template <typename FormatContext> - FMT_CONSTEXPR auto format(const Char* val, FormatContext& ctx) const - -> decltype(ctx.out()) { - return formatter<basic_string_view<Char>, Char>::format(val, ctx); - } -}; +struct formatter<Char[N], Char> : formatter<basic_string_view<Char>, Char> {}; /** - \rst - Converts ``p`` to ``const void*`` for pointer formatting. - - **Example**:: - - auto s = fmt::format("{}", fmt::ptr(p)); - \endrst + * Converts `p` to `const void*` for pointer formatting. + * + * **Example**: + * + * auto s = fmt::format("{}", fmt::ptr(p)); */ template <typename T> auto ptr(T p) -> const void* { static_assert(std::is_pointer<T>::value, ""); return detail::bit_cast<const void*>(p); } -template <typename T, typename Deleter> -auto ptr(const std::unique_ptr<T, Deleter>& p) -> const void* { - return p.get(); -} -template <typename T> auto ptr(const std::shared_ptr<T>& p) -> const void* { - return p.get(); -} /** - \rst - Converts ``e`` to the underlying type. - - **Example**:: - - enum class color { red, green, blue }; - auto s = fmt::format("{}", fmt::underlying(color::red)); - \endrst + * Converts `e` to the underlying type. + * + * **Example**: + * + * enum class color { red, green, blue }; + * auto s = fmt::format("{}", fmt::underlying(color::red)); */ template <typename Enum> constexpr auto underlying(Enum e) noexcept -> underlying_t<Enum> { @@ -4383,28 +4053,29 @@ template <> struct formatter<bytes> { } template <typename FormatContext> - auto format(bytes b, FormatContext& ctx) -> decltype(ctx.out()) { - detail::handle_dynamic_spec<detail::width_checker>(specs_.width, - specs_.width_ref, ctx); + auto format(bytes b, FormatContext& ctx) const -> decltype(ctx.out()) { + auto specs = specs_; + detail::handle_dynamic_spec<detail::width_checker>(specs.width, + specs.width_ref, ctx); detail::handle_dynamic_spec<detail::precision_checker>( - specs_.precision, specs_.precision_ref, ctx); - return detail::write_bytes(ctx.out(), b.data_, specs_); + specs.precision, specs.precision_ref, ctx); + return detail::write_bytes<char>(ctx.out(), b.data_, specs); } }; // group_digits_view is not derived from view because it copies the argument. -template <typename T> struct group_digits_view { T value; }; +template <typename T> struct group_digits_view { + T value; +}; /** - \rst - Returns a view that formats an integer value using ',' as a locale-independent - thousands separator. - - **Example**:: - - fmt::print("{}", fmt::group_digits(12345)); - // Output: "12,345" - \endrst + * Returns a view that formats an integer value using ',' as a + * locale-independent thousands separator. + * + * **Example**: + * + * fmt::print("{}", fmt::group_digits(12345)); + * // Output: "12,345" */ template <typename T> auto group_digits(T value) -> group_digits_view<T> { return {value}; @@ -4422,108 +4093,87 @@ template <typename T> struct formatter<group_digits_view<T>> : formatter<T> { } template <typename FormatContext> - auto format(group_digits_view<T> t, FormatContext& ctx) + auto format(group_digits_view<T> t, FormatContext& ctx) const -> decltype(ctx.out()) { - detail::handle_dynamic_spec<detail::width_checker>(specs_.width, - specs_.width_ref, ctx); + auto specs = specs_; + detail::handle_dynamic_spec<detail::width_checker>(specs.width, + specs.width_ref, ctx); detail::handle_dynamic_spec<detail::precision_checker>( - specs_.precision, specs_.precision_ref, ctx); + specs.precision, specs.precision_ref, ctx); + auto arg = detail::make_write_int_arg(t.value, specs.sign); return detail::write_int( - ctx.out(), static_cast<detail::uint64_or_128_t<T>>(t.value), 0, specs_, - detail::digit_grouping<char>("\3", ",")); + ctx.out(), static_cast<detail::uint64_or_128_t<T>>(arg.abs_value), + arg.prefix, specs, detail::digit_grouping<char>("\3", ",")); } }; -// DEPRECATED! join_view will be moved to ranges.h. -template <typename It, typename Sentinel, typename Char = char> -struct join_view : detail::view { - It begin; - Sentinel end; - basic_string_view<Char> sep; - - join_view(It b, Sentinel e, basic_string_view<Char> s) - : begin(b), end(e), sep(s) {} +template <typename T, typename Char> struct nested_view { + const formatter<T, Char>* fmt; + const T* value; }; -template <typename It, typename Sentinel, typename Char> -struct formatter<join_view<It, Sentinel, Char>, Char> { - private: - using value_type = -#ifdef __cpp_lib_ranges - std::iter_value_t<It>; -#else - typename std::iterator_traits<It>::value_type; -#endif - formatter<remove_cvref_t<value_type>, Char> value_formatter_; - - public: +template <typename T, typename Char> +struct formatter<nested_view<T, Char>, Char> { template <typename ParseContext> - FMT_CONSTEXPR auto parse(ParseContext& ctx) -> const Char* { - return value_formatter_.parse(ctx); + FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) { + return ctx.begin(); } - template <typename FormatContext> - auto format(const join_view<It, Sentinel, Char>& value, - FormatContext& ctx) const -> decltype(ctx.out()) { - auto it = value.begin; - auto out = ctx.out(); - if (it != value.end) { - out = value_formatter_.format(*it, ctx); - ++it; - while (it != value.end) { - out = detail::copy_str<Char>(value.sep.begin(), value.sep.end(), out); - ctx.advance_to(out); - out = value_formatter_.format(*it, ctx); - ++it; - } - } - return out; + auto format(nested_view<T, Char> view, FormatContext& ctx) const + -> decltype(ctx.out()) { + return view.fmt->format(*view.value, ctx); } }; -/** - Returns a view that formats the iterator range `[begin, end)` with elements - separated by `sep`. - */ -template <typename It, typename Sentinel> -auto join(It begin, Sentinel end, string_view sep) -> join_view<It, Sentinel> { - return {begin, end, sep}; -} - -/** - \rst - Returns a view that formats `range` with elements separated by `sep`. - - **Example**:: - - std::vector<int> v = {1, 2, 3}; - fmt::print("{}", fmt::join(v, ", ")); - // Output: "1, 2, 3" - - ``fmt::join`` applies passed format specifiers to the range elements:: +template <typename T, typename Char = char> struct nested_formatter { + private: + int width_; + detail::fill_t fill_; + align_t align_ : 4; + formatter<T, Char> formatter_; - fmt::print("{:02}", fmt::join(v, ", ")); - // Output: "01, 02, 03" - \endrst - */ -template <typename Range> -auto join(Range&& range, string_view sep) - -> join_view<detail::iterator_t<Range>, detail::sentinel_t<Range>> { - return join(std::begin(range), std::end(range), sep); -} + public: + constexpr nested_formatter() : width_(0), align_(align_t::none) {} + + FMT_CONSTEXPR auto parse(basic_format_parse_context<Char>& ctx) + -> decltype(ctx.begin()) { + auto specs = detail::dynamic_format_specs<Char>(); + auto it = parse_format_specs(ctx.begin(), ctx.end(), specs, ctx, + detail::type::none_type); + width_ = specs.width; + fill_ = specs.fill; + align_ = specs.align; + ctx.advance_to(it); + return formatter_.parse(ctx); + } + + template <typename FormatContext, typename F> + auto write_padded(FormatContext& ctx, F write) const -> decltype(ctx.out()) { + if (width_ == 0) return write(ctx.out()); + auto buf = basic_memory_buffer<Char>(); + write(basic_appender<Char>(buf)); + auto specs = format_specs(); + specs.width = width_; + specs.fill = fill_; + specs.align = align_; + return detail::write<Char>( + ctx.out(), basic_string_view<Char>(buf.data(), buf.size()), specs); + } + + auto nested(const T& value) const -> nested_view<T, Char> { + return nested_view<T, Char>{&formatter_, &value}; + } +}; /** - \rst - Converts *value* to ``std::string`` using the default format for type *T*. - - **Example**:: - - #include <fmt/format.h> - - std::string answer = fmt::to_string(42); - \endrst + * Converts `value` to `std::string` using the default format for type `T`. + * + * **Example**: + * + * std::string answer = fmt::to_string(42); */ -template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)> +template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value && + !detail::has_format_as<T>::value)> inline auto to_string(const T& value) -> std::string { auto buffer = memory_buffer(); detail::write<char>(appender(buffer), value); @@ -4548,25 +4198,33 @@ FMT_NODISCARD auto to_string(const basic_memory_buffer<Char, SIZE>& buf) return std::basic_string<Char>(buf.data(), size); } -FMT_BEGIN_DETAIL_NAMESPACE +template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value && + detail::has_format_as<T>::value)> +inline auto to_string(const T& value) -> std::string { + return to_string(format_as(value)); +} + +FMT_END_EXPORT + +namespace detail { template <typename Char> void vformat_to(buffer<Char>& buf, basic_string_view<Char> fmt, typename vformat_args<Char>::type args, locale_ref loc) { - auto out = buffer_appender<Char>(buf); + auto out = basic_appender<Char>(buf); if (fmt.size() == 2 && equal2(fmt.data(), "{}")) { auto arg = args.get(0); - if (!arg) error_handler().on_error("argument not found"); - visit_format_arg(default_arg_formatter<Char>{out, args, loc}, arg); + if (!arg) report_error("argument not found"); + arg.visit(default_arg_formatter<Char>{out, args, loc}); return; } - struct format_handler : error_handler { + struct format_handler { basic_format_parse_context<Char> parse_context; - buffer_context<Char> context; + buffered_context<Char> context; - format_handler(buffer_appender<Char> p_out, basic_string_view<Char> str, - basic_format_args<buffer_context<Char>> p_args, + format_handler(basic_appender<Char> p_out, basic_string_view<Char> str, + basic_format_args<buffered_context<Char>> p_args, locale_ref p_loc) : parse_context(str), context(p_out, p_args, p_loc) {} @@ -4579,30 +4237,28 @@ void vformat_to(buffer<Char>& buf, basic_string_view<Char> fmt, return parse_context.next_arg_id(); } FMT_CONSTEXPR auto on_arg_id(int id) -> int { - return parse_context.check_arg_id(id), id; + parse_context.check_arg_id(id); + return id; } FMT_CONSTEXPR auto on_arg_id(basic_string_view<Char> id) -> int { + parse_context.check_arg_id(id); int arg_id = context.arg_id(id); - if (arg_id < 0) on_error("argument not found"); + if (arg_id < 0) report_error("argument not found"); return arg_id; } FMT_INLINE void on_replacement_field(int id, const Char*) { auto arg = get_arg(context, id); - context.advance_to(visit_format_arg( - default_arg_formatter<Char>{context.out(), context.args(), - context.locale()}, - arg)); + context.advance_to(arg.visit(default_arg_formatter<Char>{ + context.out(), context.args(), context.locale()})); } auto on_format_specs(int id, const Char* begin, const Char* end) -> const Char* { auto arg = get_arg(context, id); - if (arg.type() == type::custom_type) { - parse_context.advance_to(begin); - visit_format_arg(custom_formatter<Char>{parse_context, context}, arg); + // Not using a visitor for custom types gives better codegen. + if (arg.format_custom(begin, parse_context, context)) return parse_context.begin(); - } auto specs = detail::dynamic_format_specs<Char>(); begin = parse_format_specs(begin, end, specs, parse_context, arg.type()); detail::handle_dynamic_spec<detail::width_checker>( @@ -4610,15 +4266,19 @@ void vformat_to(buffer<Char>& buf, basic_string_view<Char> fmt, detail::handle_dynamic_spec<detail::precision_checker>( specs.precision, specs.precision_ref, context); if (begin == end || *begin != '}') - on_error("missing '}' in format string"); - auto f = arg_formatter<Char>{context.out(), specs, context.locale()}; - context.advance_to(visit_format_arg(f, arg)); + report_error("missing '}' in format string"); + context.advance_to(arg.visit( + arg_formatter<Char>{context.out(), specs, context.locale()})); return begin; } + + FMT_NORETURN void on_error(const char* message) { report_error(message); } }; detail::parse_format_string<false>(fmt, format_handler(out, fmt, args, loc)); } +FMT_BEGIN_EXPORT + #ifndef FMT_HEADER_ONLY extern template FMT_API void vformat_to(buffer<char>&, string_view, typename vformat_args<>::type, @@ -4631,19 +4291,41 @@ extern template FMT_API auto decimal_point_impl(locale_ref) -> char; extern template FMT_API auto decimal_point_impl(locale_ref) -> wchar_t; #endif // FMT_HEADER_ONLY -FMT_END_DETAIL_NAMESPACE +FMT_END_EXPORT + +template <typename T, typename Char, type TYPE> +template <typename FormatContext> +FMT_CONSTEXPR FMT_INLINE auto native_formatter<T, Char, TYPE>::format( + const T& val, FormatContext& ctx) const -> decltype(ctx.out()) { + if (specs_.width_ref.kind == arg_id_kind::none && + specs_.precision_ref.kind == arg_id_kind::none) { + return write<Char>(ctx.out(), val, specs_, ctx.locale()); + } + auto specs = specs_; + handle_dynamic_spec<width_checker>(specs.width, specs.width_ref, ctx); + handle_dynamic_spec<precision_checker>(specs.precision, specs.precision_ref, + ctx); + return write<Char>(ctx.out(), val, specs, ctx.locale()); +} + +} // namespace detail + +FMT_BEGIN_EXPORT + +template <typename Char> +struct formatter<detail::float128, Char> + : detail::native_formatter<detail::float128, Char, + detail::type::float_type> {}; #if FMT_USE_USER_DEFINED_LITERALS inline namespace literals { /** - \rst - User-defined literal equivalent of :func:`fmt::arg`. - - **Example**:: - - using namespace fmt::literals; - fmt::print("Elapsed time: {s:.2f} seconds", "s"_a=1.23); - \endrst + * User-defined literal equivalent of `fmt::arg`. + * + * **Example**: + * + * using namespace fmt::literals; + * fmt::print("The answer is {answer}.", "answer"_a=42); */ # if FMT_USE_NONTYPE_TEMPLATE_ARGS template <detail_exported::fixed_string Str> constexpr auto operator""_a() { @@ -4651,13 +4333,30 @@ template <detail_exported::fixed_string Str> constexpr auto operator""_a() { return detail::udl_arg<char_t, sizeof(Str.data) / sizeof(char_t), Str>(); } # else -constexpr auto operator"" _a(const char* s, size_t) -> detail::udl_arg<char> { +constexpr auto operator""_a(const char* s, size_t) -> detail::udl_arg<char> { return {s}; } # endif } // namespace literals #endif // FMT_USE_USER_DEFINED_LITERALS +FMT_API auto vformat(string_view fmt, format_args args) -> std::string; + +/** + * Formats `args` according to specifications in `fmt` and returns the result + * as a string. + * + * **Example**: + * + * #include <fmt/format.h> + * std::string message = fmt::format("The answer is {}.", 42); + */ +template <typename... T> +FMT_NODISCARD FMT_INLINE auto format(format_string<T...> fmt, T&&... args) + -> std::string { + return vformat(fmt, fmt::make_format_args(args...)); +} + template <typename Locale, FMT_ENABLE_IF(detail::is_locale<Locale>::value)> inline auto vformat(const Locale& loc, string_view fmt, format_args args) -> std::string { @@ -4703,26 +4402,6 @@ FMT_NODISCARD FMT_INLINE auto formatted_size(const Locale& loc, FMT_END_EXPORT -template <typename T, typename Char> -template <typename FormatContext> -FMT_CONSTEXPR FMT_INLINE auto -formatter<T, Char, - enable_if_t<detail::type_constant<T, Char>::value != - detail::type::custom_type>>::format(const T& val, - FormatContext& ctx) - const -> decltype(ctx.out()) { - if (specs_.width_ref.kind != detail::arg_id_kind::none || - specs_.precision_ref.kind != detail::arg_id_kind::none) { - auto specs = specs_; - detail::handle_dynamic_spec<detail::width_checker>(specs.width, - specs.width_ref, ctx); - detail::handle_dynamic_spec<detail::precision_checker>( - specs.precision, specs.precision_ref, ctx); - return detail::write<Char>(ctx.out(), val, specs, ctx.locale()); - } - return detail::write<Char>(ctx.out(), val, specs_, ctx.locale()); -} - FMT_END_NAMESPACE #ifdef FMT_HEADER_ONLY @@ -4732,4 +4411,9 @@ FMT_END_NAMESPACE # define FMT_FUNC #endif +// Restore _LIBCPP_REMOVE_TRANSITIVE_INCLUDES. +#ifdef FMT_REMOVE_TRANSITIVE_INCLUDES +# undef _LIBCPP_REMOVE_TRANSITIVE_INCLUDES +#endif + #endif // FMT_FORMAT_H_ diff --git a/contrib/fmt/include/fmt/os.h b/contrib/fmt/include/fmt/os.h index ec2904021..5c85ea08f 100644 --- a/contrib/fmt/include/fmt/os.h +++ b/contrib/fmt/include/fmt/os.h @@ -8,16 +8,18 @@ #ifndef FMT_OS_H_ #define FMT_OS_H_ -#include <cerrno> -#include <cstddef> -#include <cstdio> -#include <system_error> // std::system_error +#include "format.h" -#if defined __APPLE__ || defined(__FreeBSD__) -# include <xlocale.h> // for LC_NUMERIC_MASK on OS X -#endif +#ifndef FMT_MODULE +# include <cerrno> +# include <cstddef> +# include <cstdio> +# include <system_error> // std::system_error -#include "format.h" +# if FMT_HAS_INCLUDE(<xlocale.h>) +# include <xlocale.h> // LC_NUMERIC_MASK on macOS +# endif +#endif // FMT_MODULE #ifndef FMT_USE_FCNTL // UWP doesn't provide _pipe. @@ -46,6 +48,7 @@ // Calls to system functions are wrapped in FMT_SYSTEM for testability. #ifdef FMT_SYSTEM +# define FMT_HAS_SYSTEM # define FMT_POSIX_CALL(call) FMT_SYSTEM(call) #else # define FMT_SYSTEM(call) ::call @@ -74,47 +77,34 @@ FMT_BEGIN_NAMESPACE FMT_BEGIN_EXPORT /** - \rst - A reference to a null-terminated string. It can be constructed from a C - string or ``std::string``. - - You can use one of the following type aliases for common character types: - - +---------------+-----------------------------+ - | Type | Definition | - +===============+=============================+ - | cstring_view | basic_cstring_view<char> | - +---------------+-----------------------------+ - | wcstring_view | basic_cstring_view<wchar_t> | - +---------------+-----------------------------+ - - This class is most useful as a parameter type to allow passing - different types of strings to a function, for example:: - - template <typename... Args> - std::string format(cstring_view format_str, const Args & ... args); - - format("{}", 42); - format(std::string("{}"), 42); - \endrst + * A reference to a null-terminated string. It can be constructed from a C + * string or `std::string`. + * + * You can use one of the following type aliases for common character types: + * + * +---------------+-----------------------------+ + * | Type | Definition | + * +===============+=============================+ + * | cstring_view | basic_cstring_view<char> | + * +---------------+-----------------------------+ + * | wcstring_view | basic_cstring_view<wchar_t> | + * +---------------+-----------------------------+ + * + * This class is most useful as a parameter type for functions that wrap C APIs. */ template <typename Char> class basic_cstring_view { private: const Char* data_; public: - /** Constructs a string reference object from a C string. */ + /// Constructs a string reference object from a C string. basic_cstring_view(const Char* s) : data_(s) {} - /** - \rst - Constructs a string reference from an ``std::string`` object. - \endrst - */ + /// Constructs a string reference from an `std::string` object. basic_cstring_view(const std::basic_string<Char>& s) : data_(s.c_str()) {} - /** Returns the pointer to a C string. */ - const Char* c_str() const { return data_; } + /// Returns the pointer to a C string. + auto c_str() const -> const Char* { return data_; } }; using cstring_view = basic_cstring_view<char>; @@ -123,42 +113,39 @@ using wcstring_view = basic_cstring_view<wchar_t>; #ifdef _WIN32 FMT_API const std::error_category& system_category() noexcept; -FMT_BEGIN_DETAIL_NAMESPACE +namespace detail { FMT_API void format_windows_error(buffer<char>& out, int error_code, const char* message) noexcept; -FMT_END_DETAIL_NAMESPACE +} FMT_API std::system_error vwindows_error(int error_code, string_view format_str, format_args args); /** - \rst - Constructs a :class:`std::system_error` object with the description - of the form - - .. parsed-literal:: - *<message>*: *<system-message>* - - where *<message>* is the formatted message and *<system-message>* is the - system message corresponding to the error code. - *error_code* is a Windows error code as given by ``GetLastError``. - If *error_code* is not a valid error code such as -1, the system message - will look like "error -1". - - **Example**:: - - // This throws a system_error with the description - // cannot open file 'madeup': The system cannot find the file specified. - // or similar (system message may vary). - const char *filename = "madeup"; - LPOFSTRUCT of = LPOFSTRUCT(); - HFILE file = OpenFile(filename, &of, OF_READ); - if (file == HFILE_ERROR) { - throw fmt::windows_error(GetLastError(), - "cannot open file '{}'", filename); - } - \endrst -*/ + * Constructs a `std::system_error` object with the description of the form + * + * <message>: <system-message> + * + * where `<message>` is the formatted message and `<system-message>` is the + * system message corresponding to the error code. + * `error_code` is a Windows error code as given by `GetLastError`. + * If `error_code` is not a valid error code such as -1, the system message + * will look like "error -1". + * + * **Example**: + * + * // This throws a system_error with the description + * // cannot open file 'madeup': The system cannot find the file + * specified. + * // or similar (system message may vary). + * const char *filename = "madeup"; + * LPOFSTRUCT of = LPOFSTRUCT(); + * HFILE file = OpenFile(filename, &of, OF_READ); + * if (file == HFILE_ERROR) { + * throw fmt::windows_error(GetLastError(), + * "cannot open file '{}'", filename); + * } + */ template <typename... Args> std::system_error windows_error(int error_code, string_view message, const Args&... args) { @@ -169,7 +156,7 @@ std::system_error windows_error(int error_code, string_view message, // Can be used to report errors from destructors. FMT_API void report_windows_error(int error_code, const char* message) noexcept; #else -inline const std::error_category& system_category() noexcept { +inline auto system_category() noexcept -> const std::error_category& { return std::system_category(); } #endif // _WIN32 @@ -206,7 +193,7 @@ class buffered_file { other.file_ = nullptr; } - buffered_file& operator=(buffered_file&& other) { + auto operator=(buffered_file&& other) -> buffered_file& { close(); file_ = other.file_; other.file_ = nullptr; @@ -220,21 +207,20 @@ class buffered_file { FMT_API void close(); // Returns the pointer to a FILE object representing this file. - FILE* get() const noexcept { return file_; } + auto get() const noexcept -> FILE* { return file_; } - FMT_API int descriptor() const; + FMT_API auto descriptor() const -> int; - void vprint(string_view format_str, format_args args) { - fmt::vprint(file_, format_str, args); - } - - template <typename... Args> - inline void print(string_view format_str, const Args&... args) { - vprint(format_str, fmt::make_format_args(args...)); + template <typename... T> + inline void print(string_view fmt, const T&... args) { + const auto& vargs = fmt::make_format_args(args...); + detail::is_locking<T...>() ? fmt::vprint_buffered(file_, fmt, vargs) + : fmt::vprint(file_, fmt, vargs); } }; #if FMT_USE_FCNTL + // A file. Closed file is represented by a file object with descriptor -1. // Methods that are not declared with noexcept may throw // fmt::system_error in case of failure. Note that some errors such as @@ -248,6 +234,8 @@ class FMT_API file { // Constructs a file object with a given descriptor. explicit file(int fd) : fd_(fd) {} + friend struct pipe; + public: // Possible values for the oflag argument to the constructor. enum { @@ -272,7 +260,7 @@ class FMT_API file { file(file&& other) noexcept : fd_(other.fd_) { other.fd_ = -1; } // Move assignment is not noexcept because close may throw. - file& operator=(file&& other) { + auto operator=(file&& other) -> file& { close(); fd_ = other.fd_; other.fd_ = -1; @@ -283,24 +271,24 @@ class FMT_API file { ~file() noexcept; // Returns the file descriptor. - int descriptor() const noexcept { return fd_; } + auto descriptor() const noexcept -> int { return fd_; } // Closes the file. void close(); // Returns the file size. The size has signed type for consistency with // stat::st_size. - long long size() const; + auto size() const -> long long; // Attempts to read count bytes from the file into the specified buffer. - size_t read(void* buffer, size_t count); + auto read(void* buffer, size_t count) -> size_t; // Attempts to write count bytes from the specified buffer to the file. - size_t write(const void* buffer, size_t count); + auto write(const void* buffer, size_t count) -> size_t; // Duplicates a file descriptor with the dup function and returns // the duplicate as a file object. - static file dup(int fd); + static auto dup(int fd) -> file; // Makes fd be the copy of this file descriptor, closing fd first if // necessary. @@ -310,13 +298,9 @@ class FMT_API file { // necessary. void dup2(int fd, std::error_code& ec) noexcept; - // Creates a pipe setting up read_end and write_end file objects for reading - // and writing respectively. - static void pipe(file& read_end, file& write_end); - // Creates a buffered_file object associated with this file and detaches // this file object from the file. - buffered_file fdopen(const char* mode); + auto fdopen(const char* mode) -> buffered_file; # if defined(_WIN32) && !defined(__MINGW32__) // Opens a file and constructs a file object representing this file by @@ -325,15 +309,24 @@ class FMT_API file { # endif }; +struct FMT_API pipe { + file read_end; + file write_end; + + // Creates a pipe setting up read_end and write_end file objects for reading + // and writing respectively. + pipe(); +}; + // Returns the memory page size. -long getpagesize(); +auto getpagesize() -> long; -FMT_BEGIN_DETAIL_NAMESPACE +namespace detail { struct buffer_size { buffer_size() = default; size_t value = 0; - buffer_size operator=(size_t val) const { + auto operator=(size_t val) const -> buffer_size { auto bs = buffer_size(); bs.value = val; return bs; @@ -366,13 +359,14 @@ struct ostream_params { }; class file_buffer final : public buffer<char> { + private: file file_; - FMT_API void grow(size_t) override; + FMT_API static void grow(buffer<char>& buf, size_t); public: FMT_API file_buffer(cstring_view path, const ostream_params& params); - FMT_API file_buffer(file_buffer&& other); + FMT_API file_buffer(file_buffer&& other) noexcept; FMT_API ~file_buffer(); void flush() { @@ -387,13 +381,12 @@ class file_buffer final : public buffer<char> { } }; -FMT_END_DETAIL_NAMESPACE +} // namespace detail -// Added {} below to work around default constructor error known to -// occur in Xcode versions 7.2.1 and 8.2.1. -constexpr detail::buffer_size buffer_size{}; +constexpr auto buffer_size = detail::buffer_size(); -/** A fast output stream which is not thread-safe. */ +/// A fast output stream for writing from a single thread. Writing from +/// multiple threads without external synchronization may result in a data race. class FMT_API ostream { private: FMT_MSC_WARNING(suppress : 4251) @@ -410,37 +403,32 @@ class FMT_API ostream { void flush() { buffer_.flush(); } template <typename... T> - friend ostream output_file(cstring_view path, T... params); + friend auto output_file(cstring_view path, T... params) -> ostream; void close() { buffer_.close(); } - /** - Formats ``args`` according to specifications in ``fmt`` and writes the - output to the file. - */ + /// Formats `args` according to specifications in `fmt` and writes the + /// output to the file. template <typename... T> void print(format_string<T...> fmt, T&&... args) { - vformat_to(detail::buffer_appender<char>(buffer_), fmt, - fmt::make_format_args(args...)); + vformat_to(appender(buffer_), fmt, fmt::make_format_args(args...)); } }; /** - \rst - Opens a file for writing. Supported parameters passed in *params*: - - * ``<integer>``: Flags passed to `open - <https://pubs.opengroup.org/onlinepubs/007904875/functions/open.html>`_ - (``file::WRONLY | file::CREATE | file::TRUNC`` by default) - * ``buffer_size=<integer>``: Output buffer size - - **Example**:: - - auto out = fmt::output_file("guide.txt"); - out.print("Don't {}", "Panic"); - \endrst + * Opens a file for writing. Supported parameters passed in `params`: + * + * - `<integer>`: Flags passed to [open]( + * https://pubs.opengroup.org/onlinepubs/007904875/functions/open.html) + * (`file::WRONLY | file::CREATE | file::TRUNC` by default) + * - `buffer_size=<integer>`: Output buffer size + * + * **Example**: + * + * auto out = fmt::output_file("guide.txt"); + * out.print("Don't {}", "Panic"); */ template <typename... T> -inline ostream output_file(cstring_view path, T... params) { +inline auto output_file(cstring_view path, T... params) -> ostream { return {path, detail::ostream_params(params...)}; } #endif // FMT_USE_FCNTL diff --git a/contrib/fmt/include/fmt/ostream.h b/contrib/fmt/include/fmt/ostream.h index ce65909b9..98faef659 100644 --- a/contrib/fmt/include/fmt/ostream.h +++ b/contrib/fmt/include/fmt/ostream.h @@ -8,19 +8,21 @@ #ifndef FMT_OSTREAM_H_ #define FMT_OSTREAM_H_ -#include <fstream> // std::filebuf +#ifndef FMT_MODULE +# include <fstream> // std::filebuf +#endif -#if defined(_WIN32) && defined(__GLIBCXX__) -# include <ext/stdio_filebuf.h> -# include <ext/stdio_sync_filebuf.h> -#elif defined(_WIN32) && defined(_LIBCPP_VERSION) -# include <__std_stream> +#ifdef _WIN32 +# ifdef __GLIBCXX__ +# include <ext/stdio_filebuf.h> +# include <ext/stdio_sync_filebuf.h> +# endif +# include <io.h> #endif -#include "format.h" +#include "chrono.h" // formatbuf FMT_BEGIN_NAMESPACE - namespace detail { // Generate a unique explicit instantion in every translation unit using a tag @@ -37,36 +39,40 @@ class file_access { template class file_access<file_access_tag, std::filebuf, &std::filebuf::_Myfile>; auto get_file(std::filebuf&) -> FILE*; -#elif defined(_WIN32) && defined(_LIBCPP_VERSION) -template class file_access<file_access_tag, std::__stdoutbuf<char>, - &std::__stdoutbuf<char>::__file_>; -auto get_file(std::__stdoutbuf<char>&) -> FILE*; #endif -inline bool write_ostream_unicode(std::ostream& os, fmt::string_view data) { -#if FMT_MSC_VERSION +inline auto write_ostream_unicode(std::ostream& os, fmt::string_view data) + -> bool { + FILE* f = nullptr; +#if FMT_MSC_VERSION && FMT_USE_RTTI if (auto* buf = dynamic_cast<std::filebuf*>(os.rdbuf())) - if (FILE* f = get_file(*buf)) return write_console(f, data); -#elif defined(_WIN32) && defined(__GLIBCXX__) + f = get_file(*buf); + else + return false; +#elif defined(_WIN32) && defined(__GLIBCXX__) && FMT_USE_RTTI auto* rdbuf = os.rdbuf(); - FILE* c_file; if (auto* sfbuf = dynamic_cast<__gnu_cxx::stdio_sync_filebuf<char>*>(rdbuf)) - c_file = sfbuf->file(); + f = sfbuf->file(); else if (auto* fbuf = dynamic_cast<__gnu_cxx::stdio_filebuf<char>*>(rdbuf)) - c_file = fbuf->file(); + f = fbuf->file(); else return false; - if (c_file) return write_console(c_file, data); -#elif defined(_WIN32) && defined(_LIBCPP_VERSION) - if (auto* buf = dynamic_cast<std::__stdoutbuf<char>*>(os.rdbuf())) - if (FILE* f = get_file(*buf)) return write_console(f, data); #else - ignore_unused(os, data); + ignore_unused(os, data, f); +#endif +#ifdef _WIN32 + if (f) { + int fd = _fileno(f); + if (_isatty(fd)) { + os.flush(); + return write_console(fd, data); + } + } #endif return false; } -inline bool write_ostream_unicode(std::wostream&, - fmt::basic_string_view<wchar_t>) { +inline auto write_ostream_unicode(std::wostream&, + fmt::basic_string_view<wchar_t>) -> bool { return false; } @@ -87,18 +93,19 @@ void write_buffer(std::basic_ostream<Char>& os, buffer<Char>& buf) { } template <typename Char, typename T> -void format_value(buffer<Char>& buf, const T& value, - locale_ref loc = locale_ref()) { +void format_value(buffer<Char>& buf, const T& value) { auto&& format_buf = formatbuf<std::basic_streambuf<Char>>(buf); auto&& output = std::basic_ostream<Char>(&format_buf); #if !defined(FMT_STATIC_THOUSANDS_SEPARATOR) - if (loc) output.imbue(loc.get<std::locale>()); + output.imbue(std::locale::classic()); // The default is always unlocalized. #endif output << value; output.exceptions(std::ios_base::failbit | std::ios_base::badbit); } -template <typename T> struct streamed_view { const T& value; }; +template <typename T> struct streamed_view { + const T& value; +}; } // namespace detail @@ -107,11 +114,10 @@ template <typename Char> struct basic_ostream_formatter : formatter<basic_string_view<Char>, Char> { void set_debug_format() = delete; - template <typename T, typename OutputIt> - auto format(const T& value, basic_format_context<OutputIt, Char>& ctx) const - -> OutputIt { + template <typename T, typename Context> + auto format(const T& value, Context& ctx) const -> decltype(ctx.out()) { auto buffer = basic_memory_buffer<Char>(); - detail::format_value(buffer, value, ctx.locale()); + detail::format_value(buffer, value); return formatter<basic_string_view<Char>, Char>::format( {buffer.data(), buffer.size()}, ctx); } @@ -122,25 +128,23 @@ using ostream_formatter = basic_ostream_formatter<char>; template <typename T, typename Char> struct formatter<detail::streamed_view<T>, Char> : basic_ostream_formatter<Char> { - template <typename OutputIt> - auto format(detail::streamed_view<T> view, - basic_format_context<OutputIt, Char>& ctx) const -> OutputIt { + template <typename Context> + auto format(detail::streamed_view<T> view, Context& ctx) const + -> decltype(ctx.out()) { return basic_ostream_formatter<Char>::format(view.value, ctx); } }; /** - \rst - Returns a view that formats `value` via an ostream ``operator<<``. - - **Example**:: - - fmt::print("Current thread id: {}\n", - fmt::streamed(std::this_thread::get_id())); - \endrst + * Returns a view that formats `value` via an ostream `operator<<`. + * + * **Example**: + * + * fmt::print("Current thread id: {}\n", + * fmt::streamed(std::this_thread::get_id())); */ template <typename T> -auto streamed(const T& value) -> detail::streamed_view<T> { +constexpr auto streamed(const T& value) -> detail::streamed_view<T> { return {value}; } @@ -155,10 +159,10 @@ inline void vprint_directly(std::ostream& os, string_view format_str, } // namespace detail -FMT_MODULE_EXPORT template <typename Char> +FMT_EXPORT template <typename Char> void vprint(std::basic_ostream<Char>& os, basic_string_view<type_identity_t<Char>> format_str, - basic_format_args<buffer_context<type_identity_t<Char>>> args) { + typename detail::vformat_args<Char>::type args) { auto buffer = basic_memory_buffer<Char>(); detail::vformat_to(buffer, format_str, args); if (detail::write_ostream_unicode(os, {buffer.data(), buffer.size()})) return; @@ -166,37 +170,35 @@ void vprint(std::basic_ostream<Char>& os, } /** - \rst - Prints formatted data to the stream *os*. - - **Example**:: - - fmt::print(cerr, "Don't {}!", "panic"); - \endrst + * Prints formatted data to the stream `os`. + * + * **Example**: + * + * fmt::print(cerr, "Don't {}!", "panic"); */ -FMT_MODULE_EXPORT template <typename... T> +FMT_EXPORT template <typename... T> void print(std::ostream& os, format_string<T...> fmt, T&&... args) { const auto& vargs = fmt::make_format_args(args...); - if (detail::is_utf8()) + if (detail::use_utf8()) vprint(os, fmt, vargs); else detail::vprint_directly(os, fmt, vargs); } -FMT_MODULE_EXPORT +FMT_EXPORT template <typename... Args> void print(std::wostream& os, basic_format_string<wchar_t, type_identity_t<Args>...> fmt, Args&&... args) { - vprint(os, fmt, fmt::make_format_args<buffer_context<wchar_t>>(args...)); + vprint(os, fmt, fmt::make_format_args<buffered_context<wchar_t>>(args...)); } -FMT_MODULE_EXPORT template <typename... T> +FMT_EXPORT template <typename... T> void println(std::ostream& os, format_string<T...> fmt, T&&... args) { fmt::print(os, "{}\n", fmt::format(fmt, std::forward<T>(args)...)); } -FMT_MODULE_EXPORT +FMT_EXPORT template <typename... Args> void println(std::wostream& os, basic_format_string<wchar_t, type_identity_t<Args>...> fmt, diff --git a/contrib/fmt/include/fmt/printf.h b/contrib/fmt/include/fmt/printf.h index 554715e9b..ee4b06fd5 100644 --- a/contrib/fmt/include/fmt/printf.h +++ b/contrib/fmt/include/fmt/printf.h @@ -8,107 +8,103 @@ #ifndef FMT_PRINTF_H_ #define FMT_PRINTF_H_ -#include <algorithm> // std::max -#include <limits> // std::numeric_limits +#ifndef FMT_MODULE +# include <algorithm> // std::max +# include <limits> // std::numeric_limits +#endif #include "format.h" FMT_BEGIN_NAMESPACE FMT_BEGIN_EXPORT -template <typename T> struct printf_formatter { printf_formatter() = delete; }; - -template <typename Char> -class basic_printf_parse_context : public basic_format_parse_context<Char> { - using basic_format_parse_context<Char>::basic_format_parse_context; +template <typename T> struct printf_formatter { + printf_formatter() = delete; }; -template <typename OutputIt, typename Char> class basic_printf_context { +template <typename Char> class basic_printf_context { private: - OutputIt out_; + basic_appender<Char> out_; basic_format_args<basic_printf_context> args_; + static_assert(std::is_same<Char, char>::value || + std::is_same<Char, wchar_t>::value, + "Unsupported code unit type."); + public: using char_type = Char; - using format_arg = basic_format_arg<basic_printf_context>; - using parse_context_type = basic_printf_parse_context<Char>; + using parse_context_type = basic_format_parse_context<Char>; template <typename T> using formatter_type = printf_formatter<T>; - /** - \rst - Constructs a ``printf_context`` object. References to the arguments are - stored in the context object so make sure they have appropriate lifetimes. - \endrst - */ - basic_printf_context(OutputIt out, + /// Constructs a `printf_context` object. References to the arguments are + /// stored in the context object so make sure they have appropriate lifetimes. + basic_printf_context(basic_appender<Char> out, basic_format_args<basic_printf_context> args) : out_(out), args_(args) {} - OutputIt out() { return out_; } - void advance_to(OutputIt it) { out_ = it; } - - detail::locale_ref locale() { return {}; } + auto out() -> basic_appender<Char> { return out_; } + void advance_to(basic_appender<Char>) {} - format_arg arg(int id) const { return args_.get(id); } + auto locale() -> detail::locale_ref { return {}; } - FMT_CONSTEXPR void on_error(const char* message) { - detail::error_handler().on_error(message); + auto arg(int id) const -> basic_format_arg<basic_printf_context> { + return args_.get(id); } }; -FMT_BEGIN_DETAIL_NAMESPACE +namespace detail { // Checks if a value fits in int - used to avoid warnings about comparing // signed and unsigned integers. template <bool IsSigned> struct int_checker { - template <typename T> static bool fits_in_int(T value) { - unsigned max = max_value<int>(); + template <typename T> static auto fits_in_int(T value) -> bool { + unsigned max = to_unsigned(max_value<int>()); return value <= max; } - static bool fits_in_int(bool) { return true; } + static auto fits_in_int(bool) -> bool { return true; } }; template <> struct int_checker<true> { - template <typename T> static bool fits_in_int(T value) { + template <typename T> static auto fits_in_int(T value) -> bool { return value >= (std::numeric_limits<int>::min)() && value <= max_value<int>(); } - static bool fits_in_int(int) { return true; } + static auto fits_in_int(int) -> bool { return true; } }; -class printf_precision_handler { - public: +struct printf_precision_handler { template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)> - int operator()(T value) { + auto operator()(T value) -> int { if (!int_checker<std::numeric_limits<T>::is_signed>::fits_in_int(value)) - throw_format_error("number is too big"); + report_error("number is too big"); return (std::max)(static_cast<int>(value), 0); } template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)> - int operator()(T) { - throw_format_error("precision is not integer"); + auto operator()(T) -> int { + report_error("precision is not integer"); return 0; } }; // An argument visitor that returns true iff arg is a zero integer. -class is_zero_int { - public: +struct is_zero_int { template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)> - bool operator()(T value) { + auto operator()(T value) -> bool { return value == 0; } template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)> - bool operator()(T) { + auto operator()(T) -> bool { return false; } }; template <typename T> struct make_unsigned_or_bool : std::make_unsigned<T> {}; -template <> struct make_unsigned_or_bool<bool> { using type = bool; }; +template <> struct make_unsigned_or_bool<bool> { + using type = bool; +}; template <typename T, typename Context> class arg_converter { private: @@ -132,22 +128,23 @@ template <typename T, typename Context> class arg_converter { if (const_check(sizeof(target_type) <= sizeof(int))) { // Extra casts are used to silence warnings. if (is_signed) { - arg_ = detail::make_arg<Context>( - static_cast<int>(static_cast<target_type>(value))); + auto n = static_cast<int>(static_cast<target_type>(value)); + arg_ = detail::make_arg<Context>(n); } else { using unsigned_type = typename make_unsigned_or_bool<target_type>::type; - arg_ = detail::make_arg<Context>( - static_cast<unsigned>(static_cast<unsigned_type>(value))); + auto n = static_cast<unsigned>(static_cast<unsigned_type>(value)); + arg_ = detail::make_arg<Context>(n); } } else { if (is_signed) { // glibc's printf doesn't sign extend arguments of smaller types: // std::printf("%lld", -42); // prints "4294967254" // but we don't have to do the same because it's a UB. - arg_ = detail::make_arg<Context>(static_cast<long long>(value)); + auto n = static_cast<long long>(value); + arg_ = detail::make_arg<Context>(n); } else { - arg_ = detail::make_arg<Context>( - static_cast<typename make_unsigned_or_bool<U>::type>(value)); + auto n = static_cast<typename make_unsigned_or_bool<U>::type>(value); + arg_ = detail::make_arg<Context>(n); } } } @@ -162,7 +159,7 @@ template <typename T, typename Context> class arg_converter { // unsigned). template <typename T, typename Context, typename Char> void convert_arg(basic_format_arg<Context>& arg, Char type) { - visit_format_arg(arg_converter<T, Context>(arg, type), arg); + arg.visit(arg_converter<T, Context>(arg, type)); } // Converts an integer argument to char for printf. @@ -175,8 +172,8 @@ template <typename Context> class char_converter { template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)> void operator()(T value) { - arg_ = detail::make_arg<Context>( - static_cast<typename Context::char_type>(value)); + auto c = static_cast<typename Context::char_type>(value); + arg_ = detail::make_arg<Context>(c); } template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)> @@ -186,34 +183,34 @@ template <typename Context> class char_converter { // An argument visitor that return a pointer to a C string if argument is a // string or null otherwise. template <typename Char> struct get_cstring { - template <typename T> const Char* operator()(T) { return nullptr; } - const Char* operator()(const Char* s) { return s; } + template <typename T> auto operator()(T) -> const Char* { return nullptr; } + auto operator()(const Char* s) -> const Char* { return s; } }; // Checks if an argument is a valid printf width specifier and sets // left alignment if it is negative. -template <typename Char> class printf_width_handler { +class printf_width_handler { private: - format_specs<Char>& specs_; + format_specs& specs_; public: - explicit printf_width_handler(format_specs<Char>& specs) : specs_(specs) {} + explicit printf_width_handler(format_specs& specs) : specs_(specs) {} template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)> - unsigned operator()(T value) { + auto operator()(T value) -> unsigned { auto width = static_cast<uint32_or_64_or_128_t<T>>(value); if (detail::is_negative(value)) { specs_.align = align::left; width = 0 - width; } - unsigned int_max = max_value<int>(); - if (width > int_max) throw_format_error("number is too big"); + unsigned int_max = to_unsigned(max_value<int>()); + if (width > int_max) report_error("number is too big"); return static_cast<unsigned>(width); } template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)> - unsigned operator()(T) { - throw_format_error("width is not integer"); + auto operator()(T) -> unsigned { + report_error("width is not integer"); return 0; } }; @@ -221,91 +218,91 @@ template <typename Char> class printf_width_handler { // Workaround for a bug with the XL compiler when initializing // printf_arg_formatter's base class. template <typename Char> -auto make_arg_formatter(buffer_appender<Char> iter, format_specs<Char>& s) +auto make_arg_formatter(basic_appender<Char> iter, format_specs& s) -> arg_formatter<Char> { return {iter, s, locale_ref()}; } -// The ``printf`` argument formatter. -template <typename OutputIt, typename Char> +// The `printf` argument formatter. +template <typename Char> class printf_arg_formatter : public arg_formatter<Char> { private: using base = arg_formatter<Char>; - using context_type = basic_printf_context<OutputIt, Char>; + using context_type = basic_printf_context<Char>; context_type& context_; - OutputIt write_null_pointer(bool is_string = false) { + void write_null_pointer(bool is_string = false) { auto s = this->specs; s.type = presentation_type::none; - return write_bytes(this->out, is_string ? "(null)" : "(nil)", s); + write_bytes<Char>(this->out, is_string ? "(null)" : "(nil)", s); } public: - printf_arg_formatter(OutputIt iter, format_specs<Char>& s, context_type& ctx) + printf_arg_formatter(basic_appender<Char> iter, format_specs& s, + context_type& ctx) : base(make_arg_formatter(iter, s)), context_(ctx) {} - OutputIt operator()(monostate value) { return base::operator()(value); } + void operator()(monostate value) { base::operator()(value); } template <typename T, FMT_ENABLE_IF(detail::is_integral<T>::value)> - OutputIt operator()(T value) { + void operator()(T value) { // MSVC2013 fails to compile separate overloads for bool and Char so use // std::is_same instead. - if (std::is_same<T, Char>::value) { - format_specs<Char> fmt_specs = this->specs; - if (fmt_specs.type != presentation_type::none && - fmt_specs.type != presentation_type::chr) { - return (*this)(static_cast<int>(value)); - } - fmt_specs.sign = sign::none; - fmt_specs.alt = false; - fmt_specs.fill[0] = ' '; // Ignore '0' flag for char types. - // align::numeric needs to be overwritten here since the '0' flag is - // ignored for non-numeric types - if (fmt_specs.align == align::none || fmt_specs.align == align::numeric) - fmt_specs.align = align::right; - return write<Char>(this->out, static_cast<Char>(value), fmt_specs); + if (!std::is_same<T, Char>::value) { + base::operator()(value); + return; } - return base::operator()(value); + format_specs s = this->specs; + if (s.type != presentation_type::none && s.type != presentation_type::chr) { + return (*this)(static_cast<int>(value)); + } + s.sign = sign::none; + s.alt = false; + s.fill = ' '; // Ignore '0' flag for char types. + // align::numeric needs to be overwritten here since the '0' flag is + // ignored for non-numeric types + if (s.align == align::none || s.align == align::numeric) + s.align = align::right; + write<Char>(this->out, static_cast<Char>(value), s); } template <typename T, FMT_ENABLE_IF(std::is_floating_point<T>::value)> - OutputIt operator()(T value) { - return base::operator()(value); + void operator()(T value) { + base::operator()(value); } - /** Formats a null-terminated C string. */ - OutputIt operator()(const char* value) { - if (value) return base::operator()(value); - return write_null_pointer(this->specs.type != presentation_type::pointer); + void operator()(const char* value) { + if (value) + base::operator()(value); + else + write_null_pointer(this->specs.type != presentation_type::pointer); } - /** Formats a null-terminated wide C string. */ - OutputIt operator()(const wchar_t* value) { - if (value) return base::operator()(value); - return write_null_pointer(this->specs.type != presentation_type::pointer); + void operator()(const wchar_t* value) { + if (value) + base::operator()(value); + else + write_null_pointer(this->specs.type != presentation_type::pointer); } - OutputIt operator()(basic_string_view<Char> value) { - return base::operator()(value); - } + void operator()(basic_string_view<Char> value) { base::operator()(value); } - /** Formats a pointer. */ - OutputIt operator()(const void* value) { - return value ? base::operator()(value) : write_null_pointer(); + void operator()(const void* value) { + if (value) + base::operator()(value); + else + write_null_pointer(); } - /** Formats an argument of a custom (user-defined) type. */ - OutputIt operator()(typename basic_format_arg<context_type>::handle handle) { - auto parse_ctx = - basic_printf_parse_context<Char>(basic_string_view<Char>()); + void operator()(typename basic_format_arg<context_type>::handle handle) { + auto parse_ctx = basic_format_parse_context<Char>({}); handle.format(parse_ctx, context_); - return this->out; } }; template <typename Char> -void parse_flags(format_specs<Char>& specs, const Char*& it, const Char* end) { +void parse_flags(format_specs& specs, const Char*& it, const Char* end) { for (; it != end; ++it) { switch (*it) { case '-': @@ -315,12 +312,10 @@ void parse_flags(format_specs<Char>& specs, const Char*& it, const Char* end) { specs.sign = sign::plus; break; case '0': - specs.fill[0] = '0'; + specs.fill = '0'; break; case ' ': - if (specs.sign != sign::plus) { - specs.sign = sign::space; - } + if (specs.sign != sign::plus) specs.sign = sign::space; break; case '#': specs.alt = true; @@ -332,8 +327,8 @@ void parse_flags(format_specs<Char>& specs, const Char*& it, const Char* end) { } template <typename Char, typename GetArg> -int parse_header(const Char*& it, const Char* end, format_specs<Char>& specs, - GetArg get_arg) { +auto parse_header(const Char*& it, const Char* end, format_specs& specs, + GetArg get_arg) -> int { int arg_index = -1; Char c = *it; if (c >= '0' && c <= '9') { @@ -344,11 +339,11 @@ int parse_header(const Char*& it, const Char* end, format_specs<Char>& specs, ++it; arg_index = value != -1 ? value : max_value<int>(); } else { - if (c == '0') specs.fill[0] = '0'; + if (c == '0') specs.fill = '0'; if (value != 0) { // Nonzero value means that we parsed width and don't need to // parse it or flags again, so return now. - if (value == -1) throw_format_error("number is too big"); + if (value == -1) report_error("number is too big"); specs.width = value; return arg_index; } @@ -359,17 +354,17 @@ int parse_header(const Char*& it, const Char* end, format_specs<Char>& specs, if (it != end) { if (*it >= '0' && *it <= '9') { specs.width = parse_nonnegative_int(it, end, -1); - if (specs.width == -1) throw_format_error("number is too big"); + if (specs.width == -1) report_error("number is too big"); } else if (*it == '*') { ++it; - specs.width = static_cast<int>(visit_format_arg( - detail::printf_width_handler<Char>(specs), get_arg(-1))); + specs.width = static_cast<int>( + get_arg(-1).visit(detail::printf_width_handler(specs))); } } return arg_index; } -inline auto parse_printf_presentation_type(char c, type t) +inline auto parse_printf_presentation_type(char c, type t, bool& upper) -> presentation_type { using pt = presentation_type; constexpr auto integral_set = sint_set | uint_set | bool_set | char_set; @@ -378,26 +373,31 @@ inline auto parse_printf_presentation_type(char c, type t) return in(t, integral_set) ? pt::dec : pt::none; case 'o': return in(t, integral_set) ? pt::oct : pt::none; - case 'x': - return in(t, integral_set) ? pt::hex_lower : pt::none; case 'X': - return in(t, integral_set) ? pt::hex_upper : pt::none; - case 'a': - return in(t, float_set) ? pt::hexfloat_lower : pt::none; - case 'A': - return in(t, float_set) ? pt::hexfloat_upper : pt::none; - case 'e': - return in(t, float_set) ? pt::exp_lower : pt::none; + upper = true; + FMT_FALLTHROUGH; + case 'x': + return in(t, integral_set) ? pt::hex : pt::none; case 'E': - return in(t, float_set) ? pt::exp_upper : pt::none; - case 'f': - return in(t, float_set) ? pt::fixed_lower : pt::none; + upper = true; + FMT_FALLTHROUGH; + case 'e': + return in(t, float_set) ? pt::exp : pt::none; case 'F': - return in(t, float_set) ? pt::fixed_upper : pt::none; - case 'g': - return in(t, float_set) ? pt::general_lower : pt::none; + upper = true; + FMT_FALLTHROUGH; + case 'f': + return in(t, float_set) ? pt::fixed : pt::none; case 'G': - return in(t, float_set) ? pt::general_upper : pt::none; + upper = true; + FMT_FALLTHROUGH; + case 'g': + return in(t, float_set) ? pt::general : pt::none; + case 'A': + upper = true; + FMT_FALLTHROUGH; + case 'a': + return in(t, float_set) ? pt::hexfloat : pt::none; case 'c': return in(t, integral_set) ? pt::chr : pt::none; case 's': @@ -412,10 +412,10 @@ inline auto parse_printf_presentation_type(char c, type t) template <typename Char, typename Context> void vprintf(buffer<Char>& buf, basic_string_view<Char> format, basic_format_args<Context> args) { - using iterator = buffer_appender<Char>; + using iterator = basic_appender<Char>; auto out = iterator(buf); - auto context = basic_printf_context<iterator, Char>(out, args); - auto parse_ctx = basic_printf_parse_context<Char>(format); + auto context = basic_printf_context<Char>(out, args); + auto parse_ctx = basic_format_parse_context<Char>(format); // Returns the argument with specified index or, if arg_index is -1, the next // argument. @@ -437,19 +437,18 @@ void vprintf(buffer<Char>& buf, basic_string_view<Char> format, } Char c = *it++; if (it != end && *it == c) { - out = write(out, basic_string_view<Char>(start, to_unsigned(it - start))); + write(out, basic_string_view<Char>(start, to_unsigned(it - start))); start = ++it; continue; } - out = - write(out, basic_string_view<Char>(start, to_unsigned(it - 1 - start))); + write(out, basic_string_view<Char>(start, to_unsigned(it - 1 - start))); - auto specs = format_specs<Char>(); + auto specs = format_specs(); specs.align = align::right; // Parse argument index, flags and width. int arg_index = parse_header(it, end, specs, get_arg); - if (arg_index == 0) throw_format_error("argument not found"); + if (arg_index == 0) report_error("argument not found"); // Parse precision. if (it != end && *it == '.') { @@ -459,8 +458,8 @@ void vprintf(buffer<Char>& buf, basic_string_view<Char> format, specs.precision = parse_nonnegative_int(it, end, 0); } else if (c == '*') { ++it; - specs.precision = static_cast<int>( - visit_format_arg(printf_precision_handler(), get_arg(-1))); + specs.precision = + static_cast<int>(get_arg(-1).visit(printf_precision_handler())); } else { specs.precision = 0; } @@ -469,24 +468,25 @@ void vprintf(buffer<Char>& buf, basic_string_view<Char> format, auto arg = get_arg(arg_index); // For d, i, o, u, x, and X conversion specifiers, if a precision is // specified, the '0' flag is ignored - if (specs.precision >= 0 && arg.is_integral()) - specs.fill[0] = - ' '; // Ignore '0' flag for non-numeric types or if '-' present. + if (specs.precision >= 0 && arg.is_integral()) { + // Ignore '0' for non-numeric types or if '-' present. + specs.fill = ' '; + } if (specs.precision >= 0 && arg.type() == type::cstring_type) { - auto str = visit_format_arg(get_cstring<Char>(), arg); + auto str = arg.visit(get_cstring<Char>()); auto str_end = str + specs.precision; auto nul = std::find(str, str_end, Char()); - arg = make_arg<basic_printf_context<iterator, Char>>( - basic_string_view<Char>( - str, to_unsigned(nul != str_end ? nul - str : specs.precision))); + auto sv = basic_string_view<Char>( + str, to_unsigned(nul != str_end ? nul - str : specs.precision)); + arg = make_arg<basic_printf_context<Char>>(sv); } - if (specs.alt && visit_format_arg(is_zero_int(), arg)) specs.alt = false; - if (specs.fill[0] == '0') { + if (specs.alt && arg.visit(is_zero_int())) specs.alt = false; + if (specs.fill.template get<Char>() == '0') { if (arg.is_arithmetic() && specs.align != align::left) specs.align = align::numeric; else - specs.fill[0] = ' '; // Ignore '0' flag for non-numeric types or if '-' - // flag is also present. + specs.fill = ' '; // Ignore '0' flag for non-numeric types or if '-' + // flag is also present. } // Parse length and convert the argument to the required type. @@ -530,7 +530,7 @@ void vprintf(buffer<Char>& buf, basic_string_view<Char> format, } // Parse type. - if (it == end) throw_format_error("invalid format string"); + if (it == end) report_error("invalid format string"); char type = static_cast<char>(*it++); if (arg.is_integral()) { // Normalize type. @@ -540,93 +540,71 @@ void vprintf(buffer<Char>& buf, basic_string_view<Char> format, type = 'd'; break; case 'c': - visit_format_arg( - char_converter<basic_printf_context<iterator, Char>>(arg), arg); + arg.visit(char_converter<basic_printf_context<Char>>(arg)); break; } } - specs.type = parse_printf_presentation_type(type, arg.type()); + bool upper = false; + specs.type = parse_printf_presentation_type(type, arg.type(), upper); if (specs.type == presentation_type::none) - throw_format_error("invalid format specifier"); + report_error("invalid format specifier"); + specs.upper = upper; start = it; // Format argument. - out = visit_format_arg( - printf_arg_formatter<iterator, Char>(out, specs, context), arg); + arg.visit(printf_arg_formatter<Char>(out, specs, context)); } write(out, basic_string_view<Char>(start, to_unsigned(it - start))); } -FMT_END_DETAIL_NAMESPACE +} // namespace detail -template <typename Char> -using basic_printf_context_t = - basic_printf_context<detail::buffer_appender<Char>, Char>; - -using printf_context = basic_printf_context_t<char>; -using wprintf_context = basic_printf_context_t<wchar_t>; +using printf_context = basic_printf_context<char>; +using wprintf_context = basic_printf_context<wchar_t>; using printf_args = basic_format_args<printf_context>; using wprintf_args = basic_format_args<wprintf_context>; -/** - \rst - Constructs an `~fmt::format_arg_store` object that contains references to - arguments and can be implicitly converted to `~fmt::printf_args`. - \endrst - */ -template <typename... T> -inline auto make_printf_args(const T&... args) - -> format_arg_store<printf_context, T...> { - return {args...}; +/// Constructs an `format_arg_store` object that contains references to +/// arguments and can be implicitly converted to `printf_args`. +template <typename Char = char, typename... T> +inline auto make_printf_args(T&... args) + -> decltype(make_format_args<basic_printf_context<Char>>(args...)) { + return make_format_args<basic_printf_context<Char>>(args...); } -/** - \rst - Constructs an `~fmt::format_arg_store` object that contains references to - arguments and can be implicitly converted to `~fmt::wprintf_args`. - \endrst - */ -template <typename... T> -inline auto make_wprintf_args(const T&... args) - -> format_arg_store<wprintf_context, T...> { - return {args...}; -} +template <typename Char> struct vprintf_args { + using type = basic_format_args<basic_printf_context<Char>>; +}; -template <typename S, typename Char = char_t<S>> -inline auto vsprintf( - const S& fmt, - basic_format_args<basic_printf_context_t<type_identity_t<Char>>> args) +template <typename Char> +inline auto vsprintf(basic_string_view<Char> fmt, + typename vprintf_args<Char>::type args) -> std::basic_string<Char> { auto buf = basic_memory_buffer<Char>(); - detail::vprintf(buf, detail::to_string_view(fmt), args); + detail::vprintf(buf, fmt, args); return to_string(buf); } /** - \rst - Formats arguments and returns the result as a string. - - **Example**:: - - std::string message = fmt::sprintf("The answer is %d", 42); - \endrst -*/ -template <typename S, typename... T, - typename Char = enable_if_t<detail::is_string<S>::value, char_t<S>>> + * Formats `args` according to specifications in `fmt` and returns the result + * as as string. + * + * **Example**: + * + * std::string message = fmt::sprintf("The answer is %d", 42); + */ +template <typename S, typename... T, typename Char = char_t<S>> inline auto sprintf(const S& fmt, const T&... args) -> std::basic_string<Char> { - using context = basic_printf_context_t<Char>; return vsprintf(detail::to_string_view(fmt), - fmt::make_format_args<context>(args...)); + fmt::make_format_args<basic_printf_context<Char>>(args...)); } -template <typename S, typename Char = char_t<S>> -inline auto vfprintf( - std::FILE* f, const S& fmt, - basic_format_args<basic_printf_context_t<type_identity_t<Char>>> args) - -> int { +template <typename Char> +inline auto vfprintf(std::FILE* f, basic_string_view<Char> fmt, + typename vprintf_args<Char>::type args) -> int { auto buf = basic_memory_buffer<Char>(); - detail::vprintf(buf, detail::to_string_view(fmt), args); + detail::vprintf(buf, fmt, args); size_t size = buf.size(); return std::fwrite(buf.data(), sizeof(Char), size, f) < size ? -1 @@ -634,43 +612,42 @@ inline auto vfprintf( } /** - \rst - Prints formatted data to the file *f*. - - **Example**:: - - fmt::fprintf(stderr, "Don't %s!", "panic"); - \endrst + * Formats `args` according to specifications in `fmt` and writes the output + * to `f`. + * + * **Example**: + * + * fmt::fprintf(stderr, "Don't %s!", "panic"); */ template <typename S, typename... T, typename Char = char_t<S>> inline auto fprintf(std::FILE* f, const S& fmt, const T&... args) -> int { - using context = basic_printf_context_t<Char>; return vfprintf(f, detail::to_string_view(fmt), - fmt::make_format_args<context>(args...)); + make_printf_args<Char>(args...)); } -template <typename S, typename Char = char_t<S>> -inline auto vprintf( - const S& fmt, - basic_format_args<basic_printf_context_t<type_identity_t<Char>>> args) +template <typename Char> +FMT_DEPRECATED inline auto vprintf(basic_string_view<Char> fmt, + typename vprintf_args<Char>::type args) -> int { - return vfprintf(stdout, detail::to_string_view(fmt), args); + return vfprintf(stdout, fmt, args); } /** - \rst - Prints formatted data to ``stdout``. - - **Example**:: - - fmt::printf("Elapsed time: %.2f seconds", 1.23); - \endrst + * Formats `args` according to specifications in `fmt` and writes the output + * to `stdout`. + * + * **Example**: + * + * fmt::printf("Elapsed time: %.2f seconds", 1.23); */ -template <typename S, typename... T, FMT_ENABLE_IF(detail::is_string<S>::value)> -inline auto printf(const S& fmt, const T&... args) -> int { - return vprintf( - detail::to_string_view(fmt), - fmt::make_format_args<basic_printf_context_t<char_t<S>>>(args...)); +template <typename... T> +inline auto printf(string_view fmt, const T&... args) -> int { + return vfprintf(stdout, fmt, make_printf_args(args...)); +} +template <typename... T> +FMT_DEPRECATED inline auto printf(basic_string_view<wchar_t> fmt, + const T&... args) -> int { + return vfprintf(stdout, fmt, make_printf_args<wchar_t>(args...)); } FMT_END_EXPORT diff --git a/contrib/fmt/include/fmt/ranges.h b/contrib/fmt/include/fmt/ranges.h index 266b9e1b9..f387903cf 100644 --- a/contrib/fmt/include/fmt/ranges.h +++ b/contrib/fmt/include/fmt/ranges.h @@ -1,78 +1,38 @@ -// Formatting library for C++ - experimental range support +// Formatting library for C++ - range and tuple support // -// Copyright (c) 2012 - present, Victor Zverovich +// Copyright (c) 2012 - present, Victor Zverovich and {fmt} contributors // All rights reserved. // // For the license information refer to format.h. -// -// Copyright (c) 2018 - present, Remotion (Igor Schulz) -// All Rights Reserved -// {fmt} support for ranges, containers and types tuple interface. #ifndef FMT_RANGES_H_ #define FMT_RANGES_H_ -#include <initializer_list> -#include <tuple> -#include <type_traits> +#ifndef FMT_MODULE +# include <initializer_list> +# include <iterator> +# include <string> +# include <tuple> +# include <type_traits> +# include <utility> +#endif #include "format.h" FMT_BEGIN_NAMESPACE -namespace detail { - -template <typename Range, typename OutputIt> -auto copy(const Range& range, OutputIt out) -> OutputIt { - for (auto it = range.begin(), end = range.end(); it != end; ++it) - *out++ = *it; - return out; -} - -template <typename OutputIt> -auto copy(const char* str, OutputIt out) -> OutputIt { - while (*str) *out++ = *str++; - return out; -} - -template <typename OutputIt> auto copy(char ch, OutputIt out) -> OutputIt { - *out++ = ch; - return out; -} - -template <typename OutputIt> auto copy(wchar_t ch, OutputIt out) -> OutputIt { - *out++ = ch; - return out; -} - -// Returns true if T has a std::string-like interface, like std::string_view. -template <typename T> class is_std_string_like { - template <typename U> - static auto check(U* p) - -> decltype((void)p->find('a'), p->length(), (void)p->data(), int()); - template <typename> static void check(...); - - public: - static constexpr const bool value = - is_string<T>::value || - std::is_convertible<T, std_string_view<char>>::value || - !std::is_void<decltype(check<T>(nullptr))>::value; -}; +FMT_EXPORT +enum class range_format { disabled, map, set, sequence, string, debug_string }; -template <typename Char> -struct is_std_string_like<fmt::basic_string_view<Char>> : std::true_type {}; +namespace detail { template <typename T> class is_map { template <typename U> static auto check(U*) -> typename U::mapped_type; template <typename> static void check(...); public: -#ifdef FMT_FORMAT_MAP_AS_LIST // DEPRECATED! - static constexpr const bool value = false; -#else static constexpr const bool value = !std::is_void<decltype(check<T>(nullptr))>::value; -#endif }; template <typename T> class is_set { @@ -80,12 +40,8 @@ template <typename T> class is_set { template <typename> static void check(...); public: -#ifdef FMT_FORMAT_SET_AS_LIST // DEPRECATED! - static constexpr const bool value = false; -#else static constexpr const bool value = !std::is_void<decltype(check<T>(nullptr))>::value && !is_map<T>::value; -#endif }; template <typename... Ts> struct conditional_helper {}; @@ -114,17 +70,17 @@ template <typename T, typename Enable = void> struct has_member_fn_begin_end_t : std::false_type {}; template <typename T> -struct has_member_fn_begin_end_t<T, void_t<decltype(std::declval<T>().begin()), +struct has_member_fn_begin_end_t<T, void_t<decltype(*std::declval<T>().begin()), decltype(std::declval<T>().end())>> : std::true_type {}; -// Member function overload +// Member function overloads. template <typename T> auto range_begin(T&& rng) FMT_DECLTYPE_RETURN(static_cast<T&&>(rng).begin()); template <typename T> auto range_end(T&& rng) FMT_DECLTYPE_RETURN(static_cast<T&&>(rng).end()); -// ADL overload. Only participates in overload resolution if member functions +// ADL overloads. Only participate in overload resolution if member functions // are not found. template <typename T> auto range_begin(T&& rng) @@ -145,16 +101,16 @@ struct has_mutable_begin_end : std::false_type {}; template <typename T> struct has_const_begin_end< - T, - void_t< - decltype(detail::range_begin(std::declval<const remove_cvref_t<T>&>())), - decltype(detail::range_end(std::declval<const remove_cvref_t<T>&>()))>> + T, void_t<decltype(*detail::range_begin( + std::declval<const remove_cvref_t<T>&>())), + decltype(detail::range_end( + std::declval<const remove_cvref_t<T>&>()))>> : std::true_type {}; template <typename T> struct has_mutable_begin_end< - T, void_t<decltype(detail::range_begin(std::declval<T>())), - decltype(detail::range_end(std::declval<T>())), + T, void_t<decltype(*detail::range_begin(std::declval<T&>())), + decltype(detail::range_end(std::declval<T&>())), // the extra int here is because older versions of MSVC don't // SFINAE properly unless there are distinct types int>> : std::true_type {}; @@ -187,7 +143,7 @@ template <size_t N> using make_index_sequence = std::make_index_sequence<N>; template <typename T, T... N> struct integer_sequence { using value_type = T; - static FMT_CONSTEXPR size_t size() { return sizeof...(N); } + static FMT_CONSTEXPR auto size() -> size_t { return sizeof...(N); } }; template <size_t... N> using index_sequence = integer_sequence<size_t, N...>; @@ -210,16 +166,17 @@ class is_tuple_formattable_ { static constexpr const bool value = false; }; template <typename T, typename C> class is_tuple_formattable_<T, C, true> { - template <std::size_t... Is> - static std::true_type check2(index_sequence<Is...>, - integer_sequence<bool, (Is == Is)...>); - static std::false_type check2(...); - template <std::size_t... Is> - static decltype(check2( + template <size_t... Is> + static auto all_true(index_sequence<Is...>, + integer_sequence<bool, (Is >= 0)...>) -> std::true_type; + static auto all_true(...) -> std::false_type; + + template <size_t... Is> + static auto check(index_sequence<Is...>) -> decltype(all_true( index_sequence<Is...>{}, - integer_sequence< - bool, (is_formattable<typename std::tuple_element<Is, T>::type, - C>::value)...>{})) check(index_sequence<Is...>); + integer_sequence<bool, + (is_formattable<typename std::tuple_element<Is, T>::type, + C>::value)...>{})); public: static constexpr const bool value = @@ -296,6 +253,18 @@ FMT_CONSTEXPR auto maybe_set_debug_format(Formatter& f, bool set) template <typename Formatter> FMT_CONSTEXPR void maybe_set_debug_format(Formatter&, ...) {} +template <typename T> +struct range_format_kind_ + : std::integral_constant<range_format, + std::is_same<uncvref_type<T>, T>::value + ? range_format::disabled + : is_map<T>::value ? range_format::map + : is_set<T>::value ? range_format::set + : range_format::sequence> {}; + +template <range_format K> +using range_format_constant = std::integral_constant<range_format, K>; + // These are not generic lambdas for compatibility with C++11. template <typename ParseContext> struct parse_empty_specs { template <typename Formatter> FMT_CONSTEXPR void operator()(Formatter& f) { @@ -309,8 +278,7 @@ template <typename FormatContext> struct format_tuple_element { template <typename T> void operator()(const formatter<T, char_type>& f, const T& v) { - if (i > 0) - ctx.advance_to(detail::copy_str<char_type>(separator, ctx.out())); + if (i > 0) ctx.advance_to(detail::copy<char_type>(separator, ctx.out())); ctx.advance_to(f.format(v, ctx)); ++i; } @@ -362,8 +330,7 @@ struct formatter<Tuple, Char, template <typename ParseContext> FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) { auto it = ctx.begin(); - if (it != ctx.end() && *it != '}') - FMT_THROW(format_error("invalid format specifier")); + if (it != ctx.end() && *it != '}') report_error("invalid format specifier"); detail::for_each(formatters_, detail::parse_empty_specs<ParseContext>{ctx}); return it; } @@ -371,19 +338,17 @@ struct formatter<Tuple, Char, template <typename FormatContext> auto format(const Tuple& value, FormatContext& ctx) const -> decltype(ctx.out()) { - ctx.advance_to(detail::copy_str<Char>(opening_bracket_, ctx.out())); + ctx.advance_to(detail::copy<Char>(opening_bracket_, ctx.out())); detail::for_each2( formatters_, value, detail::format_tuple_element<FormatContext>{0, ctx, separator_}); - return detail::copy_str<Char>(closing_bracket_, ctx.out()); + return detail::copy<Char>(closing_bracket_, ctx.out()); } }; template <typename T, typename Char> struct is_range { static constexpr const bool value = - detail::is_range_<T>::value && !detail::is_std_string_like<T>::value && - !std::is_convertible<T, std::basic_string<Char>>::value && - !std::is_convertible<T, detail::std_string_view<Char>>::value; + detail::is_range_<T>::value && !detail::has_to_string_view<T>::value; }; namespace detail { @@ -405,8 +370,8 @@ template <typename Context> struct range_mapper { template <typename Char, typename Element> using range_formatter_type = - formatter<remove_cvref_t<decltype(range_mapper<buffer_context<Char>>{}.map( - std::declval<Element>()))>, + formatter<remove_cvref_t<decltype(range_mapper<buffered_context<Char>>{} + .map(std::declval<Element>()))>, Char>; template <typename R> @@ -421,6 +386,12 @@ struct is_formattable_delayed #endif } // namespace detail +template <typename...> struct conjunction : std::true_type {}; +template <typename P> struct conjunction<P> : P {}; +template <typename P1, typename... Pn> +struct conjunction<P1, Pn...> + : conditional_t<bool(P1::value), conjunction<Pn...>, P1> {}; + template <typename T, typename Char, typename Enable = void> struct range_formatter; @@ -436,6 +407,24 @@ struct range_formatter< detail::string_literal<Char, '['>{}; basic_string_view<Char> closing_bracket_ = detail::string_literal<Char, ']'>{}; + bool is_debug = false; + + template <typename Output, typename It, typename Sentinel, typename U = T, + FMT_ENABLE_IF(std::is_same<U, Char>::value)> + auto write_debug_string(Output& out, It it, Sentinel end) const -> Output { + auto buf = basic_memory_buffer<Char>(); + for (; it != end; ++it) buf.push_back(*it); + auto specs = format_specs(); + specs.type = presentation_type::debug; + return detail::write<Char>( + out, basic_string_view<Char>(buf.data(), buf.size()), specs); + } + + template <typename Output, typename It, typename Sentinel, typename U = T, + FMT_ENABLE_IF(!std::is_same<U, Char>::value)> + auto write_debug_string(Output& out, It, Sentinel) const -> Output { + return out; + } public: FMT_CONSTEXPR range_formatter() {} @@ -458,17 +447,37 @@ struct range_formatter< FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) { auto it = ctx.begin(); auto end = ctx.end(); + detail::maybe_set_debug_format(underlying_, true); + if (it == end) return underlying_.parse(ctx); - if (it != end && *it == 'n') { + switch (detail::to_ascii(*it)) { + case 'n': + set_brackets({}, {}); + ++it; + break; + case '?': + is_debug = true; set_brackets({}, {}); ++it; + if (it == end || *it != 's') report_error("invalid format specifier"); + FMT_FALLTHROUGH; + case 's': + if (!std::is_same<T, Char>::value) + report_error("invalid format specifier"); + if (!is_debug) { + set_brackets(detail::string_literal<Char, '"'>{}, + detail::string_literal<Char, '"'>{}); + set_separator({}); + detail::maybe_set_debug_format(underlying_, false); + } + ++it; + return it; } if (it != end && *it != '}') { - if (*it != ':') FMT_THROW(format_error("invalid format specifier")); + if (*it != ':') report_error("invalid format specifier"); + detail::maybe_set_debug_format(underlying_, false); ++it; - } else { - detail::maybe_set_debug_format(underlying_, true); } ctx.advance_to(it); @@ -477,66 +486,151 @@ struct range_formatter< template <typename R, typename FormatContext> auto format(R&& range, FormatContext& ctx) const -> decltype(ctx.out()) { - detail::range_mapper<buffer_context<Char>> mapper; + auto mapper = detail::range_mapper<buffered_context<Char>>(); auto out = ctx.out(); - out = detail::copy_str<Char>(opening_bracket_, out); - int i = 0; auto it = detail::range_begin(range); auto end = detail::range_end(range); + if (is_debug) return write_debug_string(out, it, end); + + out = detail::copy<Char>(opening_bracket_, out); + int i = 0; for (; it != end; ++it) { - if (i > 0) out = detail::copy_str<Char>(separator_, out); + if (i > 0) out = detail::copy<Char>(separator_, out); ctx.advance_to(out); - out = underlying_.format(mapper.map(*it), ctx); + auto&& item = *it; // Need an lvalue + out = underlying_.format(mapper.map(item), ctx); ++i; } - out = detail::copy_str<Char>(closing_bracket_, out); + out = detail::copy<Char>(closing_bracket_, out); return out; } }; -enum class range_format { disabled, map, set, sequence, string, debug_string }; +FMT_EXPORT +template <typename T, typename Char, typename Enable = void> +struct range_format_kind + : conditional_t< + is_range<T, Char>::value, detail::range_format_kind_<T>, + std::integral_constant<range_format, range_format::disabled>> {}; -namespace detail { -template <typename T> -struct range_format_kind_ - : std::integral_constant<range_format, - std::is_same<uncvref_type<T>, T>::value - ? range_format::disabled - : is_map<T>::value ? range_format::map - : is_set<T>::value ? range_format::set - : range_format::sequence> {}; +template <typename R, typename Char> +struct formatter< + R, Char, + enable_if_t<conjunction< + bool_constant< + range_format_kind<R, Char>::value != range_format::disabled && + range_format_kind<R, Char>::value != range_format::map && + range_format_kind<R, Char>::value != range_format::string && + range_format_kind<R, Char>::value != range_format::debug_string> +// Workaround a bug in MSVC 2015 and earlier. +#if !FMT_MSC_VERSION || FMT_MSC_VERSION >= 1910 + , + detail::is_formattable_delayed<R, Char> +#endif + >::value>> { + private: + using range_type = detail::maybe_const_range<R>; + range_formatter<detail::uncvref_type<range_type>, Char> range_formatter_; -template <range_format K, typename R, typename Char, typename Enable = void> -struct range_default_formatter; + public: + using nonlocking = void; + + FMT_CONSTEXPR formatter() { + if (detail::const_check(range_format_kind<R, Char>::value != + range_format::set)) + return; + range_formatter_.set_brackets(detail::string_literal<Char, '{'>{}, + detail::string_literal<Char, '}'>{}); + } -template <range_format K> -using range_format_constant = std::integral_constant<range_format, K>; + template <typename ParseContext> + FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) { + return range_formatter_.parse(ctx); + } -template <range_format K, typename R, typename Char> -struct range_default_formatter< - K, R, Char, - enable_if_t<(K == range_format::sequence || K == range_format::map || - K == range_format::set)>> { - using range_type = detail::maybe_const_range<R>; - range_formatter<detail::uncvref_type<range_type>, Char> underlying_; + template <typename FormatContext> + auto format(range_type& range, FormatContext& ctx) const + -> decltype(ctx.out()) { + return range_formatter_.format(range, ctx); + } +}; + +// A map formatter. +template <typename R, typename Char> +struct formatter< + R, Char, + enable_if_t<range_format_kind<R, Char>::value == range_format::map>> { + private: + using map_type = detail::maybe_const_range<R>; + using element_type = detail::uncvref_type<map_type>; - FMT_CONSTEXPR range_default_formatter() { init(range_format_constant<K>()); } + decltype(detail::tuple::get_formatters<element_type, Char>( + detail::tuple_index_sequence<element_type>())) formatters_; + bool no_delimiters_ = false; - FMT_CONSTEXPR void init(range_format_constant<range_format::set>) { - underlying_.set_brackets(detail::string_literal<Char, '{'>{}, - detail::string_literal<Char, '}'>{}); + public: + FMT_CONSTEXPR formatter() {} + + template <typename ParseContext> + FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) { + auto it = ctx.begin(); + auto end = ctx.end(); + if (it != end) { + if (detail::to_ascii(*it) == 'n') { + no_delimiters_ = true; + ++it; + } + if (it != end && *it != '}') { + if (*it != ':') report_error("invalid format specifier"); + ++it; + } + ctx.advance_to(it); + } + detail::for_each(formatters_, detail::parse_empty_specs<ParseContext>{ctx}); + return it; } - FMT_CONSTEXPR void init(range_format_constant<range_format::map>) { - underlying_.set_brackets(detail::string_literal<Char, '{'>{}, - detail::string_literal<Char, '}'>{}); - underlying_.underlying().set_brackets({}, {}); - underlying_.underlying().set_separator( - detail::string_literal<Char, ':', ' '>{}); + template <typename FormatContext> + auto format(map_type& map, FormatContext& ctx) const -> decltype(ctx.out()) { + auto out = ctx.out(); + basic_string_view<Char> open = detail::string_literal<Char, '{'>{}; + if (!no_delimiters_) out = detail::copy<Char>(open, out); + int i = 0; + auto mapper = detail::range_mapper<buffered_context<Char>>(); + basic_string_view<Char> sep = detail::string_literal<Char, ',', ' '>{}; + for (auto&& value : map) { + if (i > 0) out = detail::copy<Char>(sep, out); + ctx.advance_to(out); + detail::for_each2(formatters_, mapper.map(value), + detail::format_tuple_element<FormatContext>{ + 0, ctx, detail::string_literal<Char, ':', ' '>{}}); + ++i; + } + basic_string_view<Char> close = detail::string_literal<Char, '}'>{}; + if (!no_delimiters_) out = detail::copy<Char>(close, out); + return out; } +}; - FMT_CONSTEXPR void init(range_format_constant<range_format::sequence>) {} +// A (debug_)string formatter. +template <typename R, typename Char> +struct formatter< + R, Char, + enable_if_t<range_format_kind<R, Char>::value == range_format::string || + range_format_kind<R, Char>::value == + range_format::debug_string>> { + private: + using range_type = detail::maybe_const_range<R>; + using string_type = + conditional_t<std::is_constructible< + detail::std_string_view<Char>, + decltype(detail::range_begin(std::declval<R>())), + decltype(detail::range_end(std::declval<R>()))>::value, + detail::std_string_view<Char>, std::basic_string<Char>>; + formatter<string_type, Char> underlying_; + + public: template <typename ParseContext> FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) { return underlying_.parse(ctx); @@ -545,32 +639,98 @@ struct range_default_formatter< template <typename FormatContext> auto format(range_type& range, FormatContext& ctx) const -> decltype(ctx.out()) { - return underlying_.format(range, ctx); + auto out = ctx.out(); + if (detail::const_check(range_format_kind<R, Char>::value == + range_format::debug_string)) + *out++ = '"'; + out = underlying_.format( + string_type{detail::range_begin(range), detail::range_end(range)}, ctx); + if (detail::const_check(range_format_kind<R, Char>::value == + range_format::debug_string)) + *out++ = '"'; + return out; } }; -} // namespace detail -template <typename T, typename Char, typename Enable = void> -struct range_format_kind - : conditional_t< - is_range<T, Char>::value, detail::range_format_kind_<T>, - std::integral_constant<range_format, range_format::disabled>> {}; +template <typename It, typename Sentinel, typename Char = char> +struct join_view : detail::view { + It begin; + Sentinel end; + basic_string_view<Char> sep; -template <typename R, typename Char> -struct formatter< - R, Char, - enable_if_t<conjunction<bool_constant<range_format_kind<R, Char>::value != - range_format::disabled> -// Workaround a bug in MSVC 2015 and earlier. -#if !FMT_MSC_VERSION || FMT_MSC_VERSION >= 1910 - , - detail::is_formattable_delayed<R, Char> + join_view(It b, Sentinel e, basic_string_view<Char> s) + : begin(std::move(b)), end(e), sep(s) {} +}; + +template <typename It, typename Sentinel, typename Char> +struct formatter<join_view<It, Sentinel, Char>, Char> { + private: + using value_type = +#ifdef __cpp_lib_ranges + std::iter_value_t<It>; +#else + typename std::iterator_traits<It>::value_type; #endif - >::value>> - : detail::range_default_formatter<range_format_kind<R, Char>::value, R, - Char> { + formatter<remove_cvref_t<value_type>, Char> value_formatter_; + + using view_ref = conditional_t<std::is_copy_constructible<It>::value, + const join_view<It, Sentinel, Char>&, + join_view<It, Sentinel, Char>&&>; + + public: + using nonlocking = void; + + template <typename ParseContext> + FMT_CONSTEXPR auto parse(ParseContext& ctx) -> const Char* { + return value_formatter_.parse(ctx); + } + + template <typename FormatContext> + auto format(view_ref& value, FormatContext& ctx) const + -> decltype(ctx.out()) { + auto it = std::forward<view_ref>(value).begin; + auto out = ctx.out(); + if (it == value.end) return out; + out = value_formatter_.format(*it, ctx); + ++it; + while (it != value.end) { + out = detail::copy<Char>(value.sep.begin(), value.sep.end(), out); + ctx.advance_to(out); + out = value_formatter_.format(*it, ctx); + ++it; + } + return out; + } }; +/// Returns a view that formats the iterator range `[begin, end)` with elements +/// separated by `sep`. +template <typename It, typename Sentinel> +auto join(It begin, Sentinel end, string_view sep) -> join_view<It, Sentinel> { + return {std::move(begin), end, sep}; +} + +/** + * Returns a view that formats `range` with elements separated by `sep`. + * + * **Example**: + * + * auto v = std::vector<int>{1, 2, 3}; + * fmt::print("{}", fmt::join(v, ", ")); + * // Output: 1, 2, 3 + * + * `fmt::join` applies passed format specifiers to the range elements: + * + * fmt::print("{:02}", fmt::join(v, ", ")); + * // Output: 01, 02, 03 + */ +template <typename Range> +auto join(Range&& r, string_view sep) + -> join_view<decltype(detail::range_begin(r)), + decltype(detail::range_end(r))> { + return {detail::range_begin(r), detail::range_end(r), sep}; +} + template <typename Char, typename... T> struct tuple_join_view : detail::view { const std::tuple<T...>& tuple; basic_string_view<Char> sep; @@ -620,7 +780,7 @@ struct formatter<tuple_join_view<Char, T...>, Char> { if (N > 1) { auto end1 = do_parse(ctx, std::integral_constant<size_t, N - 1>()); if (end != end1) - FMT_THROW(format_error("incompatible format specs for tuple elements")); + report_error("incompatible format specs for tuple elements"); } #endif return end; @@ -639,12 +799,10 @@ struct formatter<tuple_join_view<Char, T...>, Char> { typename FormatContext::iterator { auto out = std::get<sizeof...(T) - N>(formatters_) .format(std::get<sizeof...(T) - N>(value.tuple), ctx); - if (N > 1) { - out = std::copy(value.sep.begin(), value.sep.end(), out); - ctx.advance_to(out); - return do_format(value, ctx, std::integral_constant<size_t, N - 1>()); - } - return out; + if (N <= 1) return out; + out = detail::copy<Char>(value.sep, out); + ctx.advance_to(out); + return do_format(value, ctx, std::integral_constant<size_t, N - 1>()); } }; @@ -668,8 +826,11 @@ template <typename Container> struct all { } // namespace detail template <typename T, typename Char> -struct formatter<T, Char, - enable_if_t<detail::is_container_adaptor_like<T>::value>> +struct formatter< + T, Char, + enable_if_t<conjunction<detail::is_container_adaptor_like<T>, + bool_constant<range_format_kind<T, Char>::value == + range_format::disabled>>::value>> : formatter<detail::all<typename T::container_type>, Char> { using all = detail::all<typename T::container_type>; template <typename FormatContext> @@ -686,15 +847,13 @@ struct formatter<T, Char, FMT_BEGIN_EXPORT /** - \rst - Returns an object that formats `tuple` with elements separated by `sep`. - - **Example**:: - - std::tuple<int, char> t = {1, 'a'}; - fmt::print("{}", fmt::join(t, ", ")); - // Output: "1, a" - \endrst + * Returns an object that formats `std::tuple` with elements separated by `sep`. + * + * **Example**: + * + * auto t = std::tuple<int, char>{1, 'a'}; + * fmt::print("{}", fmt::join(t, ", ")); + * // Output: 1, a */ template <typename... T> FMT_CONSTEXPR auto join(const std::tuple<T...>& tuple, string_view sep) @@ -702,23 +861,14 @@ FMT_CONSTEXPR auto join(const std::tuple<T...>& tuple, string_view sep) return {tuple, sep}; } -template <typename... T> -FMT_CONSTEXPR auto join(const std::tuple<T...>& tuple, - basic_string_view<wchar_t> sep) - -> tuple_join_view<wchar_t, T...> { - return {tuple, sep}; -} - /** - \rst - Returns an object that formats `initializer_list` with elements separated by - `sep`. - - **Example**:: - - fmt::print("{}", fmt::join({1, 2, 3}, ", ")); - // Output: "1, 2, 3" - \endrst + * Returns an object that formats `std::initializer_list` with elements + * separated by `sep`. + * + * **Example**: + * + * fmt::print("{}", fmt::join({1, 2, 3}, ", ")); + * // Output: "1, 2, 3" */ template <typename T> auto join(std::initializer_list<T> list, string_view sep) diff --git a/contrib/fmt/include/fmt/std.h b/contrib/fmt/include/fmt/std.h index 4c2a28cf8..01a61cee6 100644 --- a/contrib/fmt/include/fmt/std.h +++ b/contrib/fmt/include/fmt/std.h @@ -8,30 +8,46 @@ #ifndef FMT_STD_H_ #define FMT_STD_H_ -#include <cstdlib> -#include <exception> -#include <memory> -#include <thread> -#include <type_traits> -#include <typeinfo> -#include <utility> - +#include "format.h" #include "ostream.h" -#if FMT_HAS_INCLUDE(<version>) -# include <version> -#endif -// Checking FMT_CPLUSPLUS for warning suppression in MSVC. -#if FMT_CPLUSPLUS >= 201703L -# if FMT_HAS_INCLUDE(<filesystem>) -# include <filesystem> +#ifndef FMT_MODULE +# include <atomic> +# include <bitset> +# include <complex> +# include <cstdlib> +# include <exception> +# include <memory> +# include <thread> +# include <type_traits> +# include <typeinfo> +# include <utility> +# include <vector> + +// Check FMT_CPLUSPLUS to suppress a bogus warning in MSVC. +# if FMT_CPLUSPLUS >= 201703L +# if FMT_HAS_INCLUDE(<filesystem>) +# include <filesystem> +# endif +# if FMT_HAS_INCLUDE(<variant>) +# include <variant> +# endif +# if FMT_HAS_INCLUDE(<optional>) +# include <optional> +# endif # endif -# if FMT_HAS_INCLUDE(<variant>) -# include <variant> +// Use > instead of >= in the version check because <source_location> may be +// available after C++17 but before C++20 is marked as implemented. +# if FMT_CPLUSPLUS > 201703L && FMT_HAS_INCLUDE(<source_location>) +# include <source_location> # endif -# if FMT_HAS_INCLUDE(<optional>) -# include <optional> +# if FMT_CPLUSPLUS > 202002L && FMT_HAS_INCLUDE(<expected>) +# include <expected> # endif +#endif // FMT_MODULE + +#if FMT_HAS_INCLUDE(<version>) +# include <version> #endif // GCC 4 does not support FMT_HAS_INCLUDE. @@ -44,67 +60,158 @@ # endif #endif -#ifdef __cpp_lib_filesystem +// For older Xcode versions, __cpp_lib_xxx flags are inaccurately defined. +#ifndef FMT_CPP_LIB_FILESYSTEM +# ifdef __cpp_lib_filesystem +# define FMT_CPP_LIB_FILESYSTEM __cpp_lib_filesystem +# else +# define FMT_CPP_LIB_FILESYSTEM 0 +# endif +#endif + +#ifndef FMT_CPP_LIB_VARIANT +# ifdef __cpp_lib_variant +# define FMT_CPP_LIB_VARIANT __cpp_lib_variant +# else +# define FMT_CPP_LIB_VARIANT 0 +# endif +#endif + +#if FMT_CPP_LIB_FILESYSTEM FMT_BEGIN_NAMESPACE namespace detail { -template <typename Char> -void write_escaped_path(basic_memory_buffer<Char>& quoted, - const std::filesystem::path& p) { - write_escaped_string<Char>(std::back_inserter(quoted), p.string<Char>()); -} -# ifdef _WIN32 -template <> -inline void write_escaped_path<char>(memory_buffer& quoted, - const std::filesystem::path& p) { - auto buf = basic_memory_buffer<wchar_t>(); - write_escaped_string<wchar_t>(std::back_inserter(buf), p.native()); - // Convert UTF-16 to UTF-8. - if (!unicode_to_utf8<wchar_t>::convert(quoted, {buf.data(), buf.size()})) - FMT_THROW(std::runtime_error("invalid utf16")); +template <typename Char, typename PathChar> +auto get_path_string(const std::filesystem::path& p, + const std::basic_string<PathChar>& native) { + if constexpr (std::is_same_v<Char, char> && std::is_same_v<PathChar, wchar_t>) + return to_utf8<wchar_t>(native, to_utf8_error_policy::replace); + else + return p.string<Char>(); } -# endif -template <> -inline void write_escaped_path<std::filesystem::path::value_type>( - basic_memory_buffer<std::filesystem::path::value_type>& quoted, - const std::filesystem::path& p) { - write_escaped_string<std::filesystem::path::value_type>( - std::back_inserter(quoted), p.native()); + +template <typename Char, typename PathChar> +void write_escaped_path(basic_memory_buffer<Char>& quoted, + const std::filesystem::path& p, + const std::basic_string<PathChar>& native) { + if constexpr (std::is_same_v<Char, char> && + std::is_same_v<PathChar, wchar_t>) { + auto buf = basic_memory_buffer<wchar_t>(); + write_escaped_string<wchar_t>(std::back_inserter(buf), native); + bool valid = to_utf8<wchar_t>::convert(quoted, {buf.data(), buf.size()}); + FMT_ASSERT(valid, "invalid utf16"); + } else if constexpr (std::is_same_v<Char, PathChar>) { + write_escaped_string<std::filesystem::path::value_type>( + std::back_inserter(quoted), native); + } else { + write_escaped_string<Char>(std::back_inserter(quoted), p.string<Char>()); + } } } // namespace detail -FMT_MODULE_EXPORT -template <typename Char> -struct formatter<std::filesystem::path, Char> - : formatter<basic_string_view<Char>> { +FMT_EXPORT +template <typename Char> struct formatter<std::filesystem::path, Char> { + private: + format_specs specs_; + detail::arg_ref<Char> width_ref_; + bool debug_ = false; + char path_type_ = 0; + + public: + FMT_CONSTEXPR void set_debug_format(bool set = true) { debug_ = set; } + template <typename ParseContext> FMT_CONSTEXPR auto parse(ParseContext& ctx) { - auto out = formatter<basic_string_view<Char>>::parse(ctx); - this->set_debug_format(false); - return out; + auto it = ctx.begin(), end = ctx.end(); + if (it == end) return it; + + it = detail::parse_align(it, end, specs_); + if (it == end) return it; + + it = detail::parse_dynamic_spec(it, end, specs_.width, width_ref_, ctx); + if (it != end && *it == '?') { + debug_ = true; + ++it; + } + if (it != end && (*it == 'g')) path_type_ = detail::to_ascii(*it++); + return it; } + template <typename FormatContext> - auto format(const std::filesystem::path& p, FormatContext& ctx) const -> - typename FormatContext::iterator { + auto format(const std::filesystem::path& p, FormatContext& ctx) const { + auto specs = specs_; + auto path_string = + !path_type_ ? p.native() + : p.generic_string<std::filesystem::path::value_type>(); + + detail::handle_dynamic_spec<detail::width_checker>(specs.width, width_ref_, + ctx); + if (!debug_) { + auto s = detail::get_path_string<Char>(p, path_string); + return detail::write(ctx.out(), basic_string_view<Char>(s), specs); + } auto quoted = basic_memory_buffer<Char>(); - detail::write_escaped_path(quoted, p); - return formatter<basic_string_view<Char>>::format( - basic_string_view<Char>(quoted.data(), quoted.size()), ctx); + detail::write_escaped_path(quoted, p, path_string); + return detail::write(ctx.out(), + basic_string_view<Char>(quoted.data(), quoted.size()), + specs); + } +}; + +class path : public std::filesystem::path { + public: + auto display_string() const -> std::string { + const std::filesystem::path& base = *this; + return fmt::format(FMT_STRING("{}"), base); + } + auto system_string() const -> std::string { return string(); } + + auto generic_display_string() const -> std::string { + const std::filesystem::path& base = *this; + return fmt::format(FMT_STRING("{:g}"), base); } + auto generic_system_string() const -> std::string { return generic_string(); } }; + FMT_END_NAMESPACE -#endif +#endif // FMT_CPP_LIB_FILESYSTEM FMT_BEGIN_NAMESPACE -FMT_MODULE_EXPORT +FMT_EXPORT +template <std::size_t N, typename Char> +struct formatter<std::bitset<N>, Char> : nested_formatter<string_view> { + private: + // Functor because C++11 doesn't support generic lambdas. + struct writer { + const std::bitset<N>& bs; + + template <typename OutputIt> + FMT_CONSTEXPR auto operator()(OutputIt out) -> OutputIt { + for (auto pos = N; pos > 0; --pos) { + out = detail::write<Char>(out, bs[pos - 1] ? Char('1') : Char('0')); + } + + return out; + } + }; + + public: + template <typename FormatContext> + auto format(const std::bitset<N>& bs, FormatContext& ctx) const + -> decltype(ctx.out()) { + return write_padded(ctx, writer{bs}); + } +}; + +FMT_EXPORT template <typename Char> struct formatter<std::thread::id, Char> : basic_ostream_formatter<Char> {}; FMT_END_NAMESPACE #ifdef __cpp_lib_optional FMT_BEGIN_NAMESPACE -FMT_MODULE_EXPORT +FMT_EXPORT template <typename T, typename Char> struct formatter<std::optional<T>, Char, std::enable_if_t<is_formattable<T, Char>::value>> { @@ -132,7 +239,7 @@ struct formatter<std::optional<T>, Char, } template <typename FormatContext> - auto format(std::optional<T> const& opt, FormatContext& ctx) const + auto format(const std::optional<T>& opt, FormatContext& ctx) const -> decltype(ctx.out()) { if (!opt) return detail::write<Char>(ctx.out(), none); @@ -146,24 +253,83 @@ struct formatter<std::optional<T>, Char, FMT_END_NAMESPACE #endif // __cpp_lib_optional -#ifdef __cpp_lib_variant +#if defined(__cpp_lib_expected) || FMT_CPP_LIB_VARIANT + FMT_BEGIN_NAMESPACE -FMT_MODULE_EXPORT -template <typename Char> struct formatter<std::monostate, Char> { +namespace detail { + +template <typename Char, typename OutputIt, typename T> +auto write_escaped_alternative(OutputIt out, const T& v) -> OutputIt { + if constexpr (has_to_string_view<T>::value) + return write_escaped_string<Char>(out, detail::to_string_view(v)); + if constexpr (std::is_same_v<T, Char>) return write_escaped_char(out, v); + return write<Char>(out, v); +} + +} // namespace detail + +FMT_END_NAMESPACE +#endif + +#ifdef __cpp_lib_expected +FMT_BEGIN_NAMESPACE + +FMT_EXPORT +template <typename T, typename E, typename Char> +struct formatter<std::expected<T, E>, Char, + std::enable_if_t<is_formattable<T, Char>::value && + is_formattable<E, Char>::value>> { template <typename ParseContext> FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) { return ctx.begin(); } template <typename FormatContext> - auto format(const std::monostate&, FormatContext& ctx) const + auto format(const std::expected<T, E>& value, FormatContext& ctx) const -> decltype(ctx.out()) { auto out = ctx.out(); - out = detail::write<Char>(out, "monostate"); + + if (value.has_value()) { + out = detail::write<Char>(out, "expected("); + out = detail::write_escaped_alternative<Char>(out, value.value()); + } else { + out = detail::write<Char>(out, "unexpected("); + out = detail::write_escaped_alternative<Char>(out, value.error()); + } + *out++ = ')'; return out; } }; +FMT_END_NAMESPACE +#endif // __cpp_lib_expected + +#ifdef __cpp_lib_source_location +FMT_BEGIN_NAMESPACE +FMT_EXPORT +template <> struct formatter<std::source_location> { + template <typename ParseContext> FMT_CONSTEXPR auto parse(ParseContext& ctx) { + return ctx.begin(); + } + template <typename FormatContext> + auto format(const std::source_location& loc, FormatContext& ctx) const + -> decltype(ctx.out()) { + auto out = ctx.out(); + out = detail::write(out, loc.file_name()); + out = detail::write(out, ':'); + out = detail::write<char>(out, loc.line()); + out = detail::write(out, ':'); + out = detail::write<char>(out, loc.column()); + out = detail::write(out, ": "); + out = detail::write(out, loc.function_name()); + return out; + } +}; +FMT_END_NAMESPACE +#endif + +#if FMT_CPP_LIB_VARIANT +FMT_BEGIN_NAMESPACE namespace detail { template <typename T> @@ -186,17 +352,8 @@ template <typename T, typename C> class is_variant_formattable_ { decltype(check(variant_index_sequence<T>{}))::value; }; -template <typename Char, typename OutputIt, typename T> -auto write_variant_alternative(OutputIt out, const T& v) -> OutputIt { - if constexpr (is_string<T>::value) - return write_escaped_string<Char>(out, detail::to_string_view(v)); - else if constexpr (std::is_same_v<T, Char>) - return write_escaped_char(out, v); - else - return write<Char>(out, v); -} - } // namespace detail + template <typename T> struct is_variant_like { static constexpr const bool value = detail::is_variant_like_<T>::value; }; @@ -206,7 +363,21 @@ template <typename T, typename C> struct is_variant_formattable { detail::is_variant_formattable_<T, C>::value; }; -FMT_MODULE_EXPORT +FMT_EXPORT +template <typename Char> struct formatter<std::monostate, Char> { + template <typename ParseContext> + FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) { + return ctx.begin(); + } + + template <typename FormatContext> + auto format(const std::monostate&, FormatContext& ctx) const + -> decltype(ctx.out()) { + return detail::write<Char>(ctx.out(), "monostate"); + } +}; + +FMT_EXPORT template <typename Variant, typename Char> struct formatter< Variant, Char, @@ -223,13 +394,14 @@ struct formatter< auto out = ctx.out(); out = detail::write<Char>(out, "variant("); - try { + FMT_TRY { std::visit( [&](const auto& v) { - out = detail::write_variant_alternative<Char>(out, v); + out = detail::write_escaped_alternative<Char>(out, v); }, value); - } catch (const std::bad_variant_access&) { + } + FMT_CATCH(const std::bad_variant_access&) { detail::write<Char>(out, "valueless by exception"); } *out++ = ')'; @@ -237,10 +409,10 @@ struct formatter< } }; FMT_END_NAMESPACE -#endif // __cpp_lib_variant +#endif // FMT_CPP_LIB_VARIANT FMT_BEGIN_NAMESPACE -FMT_MODULE_EXPORT +FMT_EXPORT template <typename Char> struct formatter<std::error_code, Char> { template <typename ParseContext> FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) { @@ -251,17 +423,106 @@ template <typename Char> struct formatter<std::error_code, Char> { FMT_CONSTEXPR auto format(const std::error_code& ec, FormatContext& ctx) const -> decltype(ctx.out()) { auto out = ctx.out(); - out = detail::write_bytes(out, ec.category().name(), format_specs<Char>()); + out = detail::write_bytes<Char>(out, ec.category().name(), format_specs()); out = detail::write<Char>(out, Char(':')); out = detail::write<Char>(out, ec.value()); return out; } }; -FMT_MODULE_EXPORT +#if FMT_USE_RTTI +namespace detail { + +template <typename Char, typename OutputIt> +auto write_demangled_name(OutputIt out, const std::type_info& ti) -> OutputIt { +# ifdef FMT_HAS_ABI_CXA_DEMANGLE + int status = 0; + std::size_t size = 0; + std::unique_ptr<char, void (*)(void*)> demangled_name_ptr( + abi::__cxa_demangle(ti.name(), nullptr, &size, &status), &std::free); + + string_view demangled_name_view; + if (demangled_name_ptr) { + demangled_name_view = demangled_name_ptr.get(); + + // Normalization of stdlib inline namespace names. + // libc++ inline namespaces. + // std::__1::* -> std::* + // std::__1::__fs::* -> std::* + // libstdc++ inline namespaces. + // std::__cxx11::* -> std::* + // std::filesystem::__cxx11::* -> std::filesystem::* + if (demangled_name_view.starts_with("std::")) { + char* begin = demangled_name_ptr.get(); + char* to = begin + 5; // std:: + for (char *from = to, *end = begin + demangled_name_view.size(); + from < end;) { + // This is safe, because demangled_name is NUL-terminated. + if (from[0] == '_' && from[1] == '_') { + char* next = from + 1; + while (next < end && *next != ':') next++; + if (next[0] == ':' && next[1] == ':') { + from = next + 2; + continue; + } + } + *to++ = *from++; + } + demangled_name_view = {begin, detail::to_unsigned(to - begin)}; + } + } else { + demangled_name_view = string_view(ti.name()); + } + return detail::write_bytes<Char>(out, demangled_name_view); +# elif FMT_MSC_VERSION + const string_view demangled_name(ti.name()); + for (std::size_t i = 0; i < demangled_name.size(); ++i) { + auto sub = demangled_name; + sub.remove_prefix(i); + if (sub.starts_with("enum ")) { + i += 4; + continue; + } + if (sub.starts_with("class ") || sub.starts_with("union ")) { + i += 5; + continue; + } + if (sub.starts_with("struct ")) { + i += 6; + continue; + } + if (*sub.begin() != ' ') *out++ = *sub.begin(); + } + return out; +# else + return detail::write_bytes<Char>(out, string_view(ti.name())); +# endif +} + +} // namespace detail + +FMT_EXPORT +template <typename Char> +struct formatter<std::type_info, Char // DEPRECATED! Mixing code unit types. + > { + public: + FMT_CONSTEXPR auto parse(basic_format_parse_context<Char>& ctx) + -> decltype(ctx.begin()) { + return ctx.begin(); + } + + template <typename Context> + auto format(const std::type_info& ti, Context& ctx) const + -> decltype(ctx.out()) { + return detail::write_demangled_name<Char>(ctx.out(), ti); + } +}; +#endif + +FMT_EXPORT template <typename T, typename Char> struct formatter< - T, Char, + T, Char, // DEPRECATED! Mixing code unit types. typename std::enable_if<std::is_base_of<std::exception, T>::value>::type> { private: bool with_typename_ = false; @@ -274,76 +535,131 @@ struct formatter< if (it == end || *it == '}') return it; if (*it == 't') { ++it; - with_typename_ = true; + with_typename_ = FMT_USE_RTTI != 0; } return it; } - template <typename OutputIt> - auto format(const std::exception& ex, - basic_format_context<OutputIt, Char>& ctx) const -> OutputIt { - format_specs<Char> spec; + template <typename Context> + auto format(const std::exception& ex, Context& ctx) const + -> decltype(ctx.out()) { auto out = ctx.out(); - if (!with_typename_) - return detail::write_bytes(out, string_view(ex.what()), spec); - - const std::type_info& ti = typeid(ex); -#ifdef FMT_HAS_ABI_CXA_DEMANGLE - int status = 0; - std::size_t size = 0; - std::unique_ptr<char, decltype(&std::free)> demangled_name_ptr( - abi::__cxa_demangle(ti.name(), nullptr, &size, &status), &std::free); - - string_view demangled_name_view; - if (demangled_name_ptr) { - demangled_name_view = demangled_name_ptr.get(); - - // Normalization of stdlib inline namespace names. - // libc++ inline namespaces. - // std::__1::* -> std::* - // std::__1::__fs::* -> std::* - // libstdc++ inline namespaces. - // std::__cxx11::* -> std::* - // std::filesystem::__cxx11::* -> std::filesystem::* - if (demangled_name_view.starts_with("std::")) { - char* begin = demangled_name_ptr.get(); - char* to = begin + 5; // std:: - for (char *from = to, *end = begin + demangled_name_view.size(); - from < end;) { - // This is safe, because demangled_name is NUL-terminated. - if (from[0] == '_' && from[1] == '_') { - char* next = from + 1; - while (next < end && *next != ':') next++; - if (next[0] == ':' && next[1] == ':') { - from = next + 2; - continue; - } - } - *to++ = *from++; - } - demangled_name_view = {begin, detail::to_unsigned(to - begin)}; - } - } else { - demangled_name_view = string_view(ti.name()); +#if FMT_USE_RTTI + if (with_typename_) { + out = detail::write_demangled_name<Char>(out, typeid(ex)); + *out++ = ':'; + *out++ = ' '; } - out = detail::write_bytes(out, demangled_name_view, spec); -#elif FMT_MSC_VERSION - string_view demangled_name_view(ti.name()); - if (demangled_name_view.starts_with("class ")) - demangled_name_view.remove_prefix(6); - else if (demangled_name_view.starts_with("struct ")) - demangled_name_view.remove_prefix(7); - out = detail::write_bytes(out, demangled_name_view, spec); -#else - out = detail::write_bytes(out, string_view(ti.name()), spec); #endif - out = detail::write<Char>(out, Char(':')); - out = detail::write<Char>(out, Char(' ')); - out = detail::write_bytes(out, string_view(ex.what()), spec); + return detail::write_bytes<Char>(out, string_view(ex.what())); + } +}; - return out; +namespace detail { + +template <typename T, typename Enable = void> +struct has_flip : std::false_type {}; + +template <typename T> +struct has_flip<T, void_t<decltype(std::declval<T>().flip())>> + : std::true_type {}; + +template <typename T> struct is_bit_reference_like { + static constexpr const bool value = + std::is_convertible<T, bool>::value && + std::is_nothrow_assignable<T, bool>::value && has_flip<T>::value; +}; + +#ifdef _LIBCPP_VERSION + +// Workaround for libc++ incompatibility with C++ standard. +// According to the Standard, `bitset::operator[] const` returns bool. +template <typename C> +struct is_bit_reference_like<std::__bit_const_reference<C>> { + static constexpr const bool value = true; +}; + +#endif + +} // namespace detail + +// We can't use std::vector<bool, Allocator>::reference and +// std::bitset<N>::reference because the compiler can't deduce Allocator and N +// in partial specialization. +FMT_EXPORT +template <typename BitRef, typename Char> +struct formatter<BitRef, Char, + enable_if_t<detail::is_bit_reference_like<BitRef>::value>> + : formatter<bool, Char> { + template <typename FormatContext> + FMT_CONSTEXPR auto format(const BitRef& v, FormatContext& ctx) const + -> decltype(ctx.out()) { + return formatter<bool, Char>::format(v, ctx); } }; -FMT_END_NAMESPACE +template <typename T, typename Deleter> +auto ptr(const std::unique_ptr<T, Deleter>& p) -> const void* { + return p.get(); +} +template <typename T> auto ptr(const std::shared_ptr<T>& p) -> const void* { + return p.get(); +} + +FMT_EXPORT +template <typename T, typename Char> +struct formatter<std::atomic<T>, Char, + enable_if_t<is_formattable<T, Char>::value>> + : formatter<T, Char> { + template <typename FormatContext> + auto format(const std::atomic<T>& v, FormatContext& ctx) const + -> decltype(ctx.out()) { + return formatter<T, Char>::format(v.load(), ctx); + } +}; + +#ifdef __cpp_lib_atomic_flag_test +FMT_EXPORT +template <typename Char> +struct formatter<std::atomic_flag, Char> : formatter<bool, Char> { + template <typename FormatContext> + auto format(const std::atomic_flag& v, FormatContext& ctx) const + -> decltype(ctx.out()) { + return formatter<bool, Char>::format(v.test(), ctx); + } +}; +#endif // __cpp_lib_atomic_flag_test + +FMT_EXPORT +template <typename F, typename Char> +struct formatter<std::complex<F>, Char> : nested_formatter<F, Char> { + private: + // Functor because C++11 doesn't support generic lambdas. + struct writer { + const formatter<std::complex<F>, Char>* f; + const std::complex<F>& c; + + template <typename OutputIt> + FMT_CONSTEXPR auto operator()(OutputIt out) -> OutputIt { + if (c.real() != 0) { + auto format_full = detail::string_literal<Char, '(', '{', '}', '+', '{', + '}', 'i', ')'>{}; + return fmt::format_to(out, basic_string_view<Char>(format_full), + f->nested(c.real()), f->nested(c.imag())); + } + auto format_imag = detail::string_literal<Char, '{', '}', 'i'>{}; + return fmt::format_to(out, basic_string_view<Char>(format_imag), + f->nested(c.imag())); + } + }; + + public: + template <typename FormatContext> + auto format(const std::complex<F>& c, FormatContext& ctx) const + -> decltype(ctx.out()) { + return this->write_padded(ctx, writer{this, c}); + } +}; + +FMT_END_NAMESPACE #endif // FMT_STD_H_ diff --git a/contrib/fmt/include/fmt/xchar.h b/contrib/fmt/include/fmt/xchar.h index 4b87f8d12..b1f39ed22 100644 --- a/contrib/fmt/include/fmt/xchar.h +++ b/contrib/fmt/include/fmt/xchar.h @@ -8,12 +8,15 @@ #ifndef FMT_XCHAR_H_ #define FMT_XCHAR_H_ -#include <cwchar> - +#include "color.h" #include "format.h" +#include "ranges.h" -#ifndef FMT_STATIC_THOUSANDS_SEPARATOR -# include <locale> +#ifndef FMT_MODULE +# include <cwchar> +# if !defined(FMT_STATIC_THOUSANDS_SEPARATOR) +# include <locale> +# endif #endif FMT_BEGIN_NAMESPACE @@ -22,9 +25,24 @@ namespace detail { template <typename T> using is_exotic_char = bool_constant<!std::is_same<T, char>::value>; -inline auto write_loc(std::back_insert_iterator<detail::buffer<wchar_t>> out, - loc_value value, const format_specs<wchar_t>& specs, - locale_ref loc) -> bool { +template <typename S, typename = void> struct format_string_char {}; + +template <typename S> +struct format_string_char< + S, void_t<decltype(sizeof(detail::to_string_view(std::declval<S>())))>> { + using type = char_t<S>; +}; + +template <typename S> +struct format_string_char<S, enable_if_t<is_compile_string<S>::value>> { + using type = typename S::char_type; +}; + +template <typename S> +using format_string_char_t = typename format_string_char<S>::type; + +inline auto write_loc(basic_appender<wchar_t> out, loc_value value, + const format_specs& specs, locale_ref loc) -> bool { #ifndef FMT_STATIC_THOUSANDS_SEPARATOR auto& numpunct = std::use_facet<std::numpunct<wchar_t>>(loc.get<std::locale>()); @@ -41,7 +59,7 @@ FMT_BEGIN_EXPORT using wstring_view = basic_string_view<wchar_t>; using wformat_parse_context = basic_format_parse_context<wchar_t>; -using wformat_context = buffer_context<wchar_t>; +using wformat_context = buffered_context<wchar_t>; using wformat_args = basic_format_args<wformat_context>; using wmemory_buffer = basic_memory_buffer<wchar_t>; @@ -58,19 +76,24 @@ inline auto runtime(wstring_view s) -> runtime_format_string<wchar_t> { #endif template <> struct is_char<wchar_t> : std::true_type {}; -template <> struct is_char<detail::char8_type> : std::true_type {}; template <> struct is_char<char16_t> : std::true_type {}; template <> struct is_char<char32_t> : std::true_type {}; -template <typename... Args> -constexpr format_arg_store<wformat_context, Args...> make_wformat_args( - const Args&... args) { - return {args...}; +#ifdef __cpp_char8_t +template <> +struct is_char<char8_t> : bool_constant<detail::is_utf8_enabled()> {}; +#endif + +template <typename... T> +constexpr auto make_wformat_args(T&... args) + -> decltype(fmt::make_format_args<wformat_context>(args...)) { + return fmt::make_format_args<wformat_context>(args...); } inline namespace literals { #if FMT_USE_USER_DEFINED_LITERALS && !FMT_USE_NONTYPE_TEMPLATE_ARGS -constexpr detail::udl_arg<wchar_t> operator"" _a(const wchar_t* s, size_t) { +constexpr auto operator""_a(const wchar_t* s, size_t) + -> detail::udl_arg<wchar_t> { return {s}; } #endif @@ -95,13 +118,19 @@ auto join(std::initializer_list<T> list, wstring_view sep) return join(std::begin(list), std::end(list), sep); } +template <typename... T> +auto join(const std::tuple<T...>& tuple, basic_string_view<wchar_t> sep) + -> tuple_join_view<wchar_t, T...> { + return {tuple, sep}; +} + template <typename Char, FMT_ENABLE_IF(!std::is_same<Char, char>::value)> auto vformat(basic_string_view<Char> format_str, - basic_format_args<buffer_context<type_identity_t<Char>>> args) + typename detail::vformat_args<Char>::type args) -> std::basic_string<Char> { - basic_memory_buffer<Char> buffer; - detail::vformat_to(buffer, format_str, args); - return to_string(buffer); + auto buf = basic_memory_buffer<Char>(); + detail::vformat_to(buf, format_str, args); + return to_string(buf); } template <typename... T> @@ -109,119 +138,130 @@ auto format(wformat_string<T...> fmt, T&&... args) -> std::wstring { return vformat(fmt::wstring_view(fmt), fmt::make_wformat_args(args...)); } +template <typename OutputIt, typename... T> +auto format_to(OutputIt out, wformat_string<T...> fmt, T&&... args) + -> OutputIt { + return vformat_to(out, fmt::wstring_view(fmt), + fmt::make_wformat_args(args...)); +} + // Pass char_t as a default template parameter instead of using // std::basic_string<char_t<S>> to reduce the symbol size. -template <typename S, typename... Args, typename Char = char_t<S>, +template <typename S, typename... T, + typename Char = detail::format_string_char_t<S>, FMT_ENABLE_IF(!std::is_same<Char, char>::value && !std::is_same<Char, wchar_t>::value)> -auto format(const S& format_str, Args&&... args) -> std::basic_string<Char> { +auto format(const S& format_str, T&&... args) -> std::basic_string<Char> { return vformat(detail::to_string_view(format_str), - fmt::make_format_args<buffer_context<Char>>(args...)); + fmt::make_format_args<buffered_context<Char>>(args...)); } -template <typename Locale, typename S, typename Char = char_t<S>, +template <typename Locale, typename S, + typename Char = detail::format_string_char_t<S>, FMT_ENABLE_IF(detail::is_locale<Locale>::value&& detail::is_exotic_char<Char>::value)> -inline auto vformat( - const Locale& loc, const S& format_str, - basic_format_args<buffer_context<type_identity_t<Char>>> args) +inline auto vformat(const Locale& loc, const S& format_str, + typename detail::vformat_args<Char>::type args) -> std::basic_string<Char> { return detail::vformat(loc, detail::to_string_view(format_str), args); } -template <typename Locale, typename S, typename... Args, - typename Char = char_t<S>, +template <typename Locale, typename S, typename... T, + typename Char = detail::format_string_char_t<S>, FMT_ENABLE_IF(detail::is_locale<Locale>::value&& detail::is_exotic_char<Char>::value)> -inline auto format(const Locale& loc, const S& format_str, Args&&... args) +inline auto format(const Locale& loc, const S& format_str, T&&... args) -> std::basic_string<Char> { - return detail::vformat(loc, detail::to_string_view(format_str), - fmt::make_format_args<buffer_context<Char>>(args...)); + return detail::vformat( + loc, detail::to_string_view(format_str), + fmt::make_format_args<buffered_context<Char>>(args...)); } -template <typename OutputIt, typename S, typename Char = char_t<S>, +template <typename OutputIt, typename S, + typename Char = detail::format_string_char_t<S>, FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value&& detail::is_exotic_char<Char>::value)> auto vformat_to(OutputIt out, const S& format_str, - basic_format_args<buffer_context<type_identity_t<Char>>> args) - -> OutputIt { + typename detail::vformat_args<Char>::type args) -> OutputIt { auto&& buf = detail::get_buffer<Char>(out); detail::vformat_to(buf, detail::to_string_view(format_str), args); return detail::get_iterator(buf, out); } -template <typename OutputIt, typename S, typename... Args, - typename Char = char_t<S>, - FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value&& - detail::is_exotic_char<Char>::value)> -inline auto format_to(OutputIt out, const S& fmt, Args&&... args) -> OutputIt { +template <typename OutputIt, typename S, typename... T, + typename Char = detail::format_string_char_t<S>, + FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value && + !std::is_same<Char, char>::value && + !std::is_same<Char, wchar_t>::value)> +inline auto format_to(OutputIt out, const S& fmt, T&&... args) -> OutputIt { return vformat_to(out, detail::to_string_view(fmt), - fmt::make_format_args<buffer_context<Char>>(args...)); + fmt::make_format_args<buffered_context<Char>>(args...)); } template <typename Locale, typename S, typename OutputIt, typename... Args, - typename Char = char_t<S>, + typename Char = detail::format_string_char_t<S>, FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value&& detail::is_locale<Locale>::value&& detail::is_exotic_char<Char>::value)> -inline auto vformat_to( - OutputIt out, const Locale& loc, const S& format_str, - basic_format_args<buffer_context<type_identity_t<Char>>> args) -> OutputIt { +inline auto vformat_to(OutputIt out, const Locale& loc, const S& format_str, + typename detail::vformat_args<Char>::type args) + -> OutputIt { auto&& buf = detail::get_buffer<Char>(out); vformat_to(buf, detail::to_string_view(format_str), args, detail::locale_ref(loc)); return detail::get_iterator(buf, out); } -template < - typename OutputIt, typename Locale, typename S, typename... Args, - typename Char = char_t<S>, - bool enable = detail::is_output_iterator<OutputIt, Char>::value&& - detail::is_locale<Locale>::value&& detail::is_exotic_char<Char>::value> +template <typename OutputIt, typename Locale, typename S, typename... T, + typename Char = detail::format_string_char_t<S>, + bool enable = detail::is_output_iterator<OutputIt, Char>::value && + detail::is_locale<Locale>::value && + detail::is_exotic_char<Char>::value> inline auto format_to(OutputIt out, const Locale& loc, const S& format_str, - Args&&... args) -> + T&&... args) -> typename std::enable_if<enable, OutputIt>::type { return vformat_to(out, loc, detail::to_string_view(format_str), - fmt::make_format_args<buffer_context<Char>>(args...)); + fmt::make_format_args<buffered_context<Char>>(args...)); } template <typename OutputIt, typename Char, typename... Args, FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value&& detail::is_exotic_char<Char>::value)> -inline auto vformat_to_n( - OutputIt out, size_t n, basic_string_view<Char> format_str, - basic_format_args<buffer_context<type_identity_t<Char>>> args) +inline auto vformat_to_n(OutputIt out, size_t n, + basic_string_view<Char> format_str, + typename detail::vformat_args<Char>::type args) -> format_to_n_result<OutputIt> { - detail::iterator_buffer<OutputIt, Char, detail::fixed_buffer_traits> buf(out, - n); + using traits = detail::fixed_buffer_traits; + auto buf = detail::iterator_buffer<OutputIt, Char, traits>(out, n); detail::vformat_to(buf, format_str, args); return {buf.out(), buf.count()}; } -template <typename OutputIt, typename S, typename... Args, - typename Char = char_t<S>, +template <typename OutputIt, typename S, typename... T, + typename Char = detail::format_string_char_t<S>, FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value&& detail::is_exotic_char<Char>::value)> -inline auto format_to_n(OutputIt out, size_t n, const S& fmt, - const Args&... args) -> format_to_n_result<OutputIt> { - return vformat_to_n(out, n, detail::to_string_view(fmt), - fmt::make_format_args<buffer_context<Char>>(args...)); +inline auto format_to_n(OutputIt out, size_t n, const S& fmt, T&&... args) + -> format_to_n_result<OutputIt> { + return vformat_to_n(out, n, fmt::basic_string_view<Char>(fmt), + fmt::make_format_args<buffered_context<Char>>(args...)); } -template <typename S, typename... Args, typename Char = char_t<S>, +template <typename S, typename... T, + typename Char = detail::format_string_char_t<S>, FMT_ENABLE_IF(detail::is_exotic_char<Char>::value)> -inline auto formatted_size(const S& fmt, Args&&... args) -> size_t { - detail::counting_buffer<Char> buf; +inline auto formatted_size(const S& fmt, T&&... args) -> size_t { + auto buf = detail::counting_buffer<Char>(); detail::vformat_to(buf, detail::to_string_view(fmt), - fmt::make_format_args<buffer_context<Char>>(args...)); + fmt::make_format_args<buffered_context<Char>>(args...)); return buf.count(); } inline void vprint(std::FILE* f, wstring_view fmt, wformat_args args) { - wmemory_buffer buffer; - detail::vformat_to(buffer, fmt, args); - buffer.push_back(L'\0'); - if (std::fputws(buffer.data(), f) == -1) + auto buf = wmemory_buffer(); + detail::vformat_to(buf, fmt, args); + buf.push_back(L'\0'); + if (std::fputws(buf.data(), f) == -1) FMT_THROW(system_error(errno, FMT_STRING("cannot write to file"))); } @@ -247,9 +287,32 @@ template <typename... T> void println(wformat_string<T...> fmt, T&&... args) { return print(L"{}\n", fmt::format(fmt, std::forward<T>(args)...)); } -/** - Converts *value* to ``std::wstring`` using the default format for type *T*. - */ +inline auto vformat(const text_style& ts, wstring_view fmt, wformat_args args) + -> std::wstring { + auto buf = wmemory_buffer(); + detail::vformat_to(buf, ts, fmt, args); + return fmt::to_string(buf); +} + +template <typename... T> +inline auto format(const text_style& ts, wformat_string<T...> fmt, T&&... args) + -> std::wstring { + return fmt::vformat(ts, fmt, fmt::make_wformat_args(args...)); +} + +template <typename... T> +FMT_DEPRECATED void print(std::FILE* f, const text_style& ts, + wformat_string<T...> fmt, const T&... args) { + vprint(f, ts, fmt, fmt::make_wformat_args(args...)); +} + +template <typename... T> +FMT_DEPRECATED void print(const text_style& ts, wformat_string<T...> fmt, + const T&... args) { + return print(stdout, ts, fmt, args...); +} + +/// Converts `value` to `std::wstring` using the default format for type `T`. template <typename T> inline auto to_wstring(const T& value) -> std::wstring { return format(FMT_STRING(L"{}"), value); } diff --git a/src/client/rspamc.cxx b/src/client/rspamc.cxx index 5a9a654e4..1e0830493 100644 --- a/src/client/rspamc.cxx +++ b/src/client/rspamc.cxx @@ -1053,21 +1053,21 @@ rspamc_metric_output(FILE *out, const ucl_object_t *obj) std::string colorized_action; switch (act.value()) { case METRIC_ACTION_REJECT: - colorized_action = fmt::format(fmt::fg(fmt::color::red), "reject"); + colorized_action = fmt::format(fmt::fg(fmt::color::red), "{}", "reject"); break; case METRIC_ACTION_NOACTION: - colorized_action = fmt::format(fmt::fg(fmt::color::green), "no action"); + colorized_action = fmt::format(fmt::fg(fmt::color::green), "{}", "no action"); break; case METRIC_ACTION_ADD_HEADER: case METRIC_ACTION_REWRITE_SUBJECT: - colorized_action = fmt::format(fmt::fg(fmt::color::orange), ucl_object_tostring(elt)); + colorized_action = fmt::format(fmt::fg(fmt::color::orange), "{}", ucl_object_tostring(elt)); break; case METRIC_ACTION_GREYLIST: case METRIC_ACTION_SOFT_REJECT: - colorized_action = fmt::format(fmt::fg(fmt::color::gray), ucl_object_tostring(elt)); + colorized_action = fmt::format(fmt::fg(fmt::color::gray), "{}", ucl_object_tostring(elt)); break; default: - colorized_action = fmt::format(fmt::emphasis::bold, ucl_object_tostring(elt)); + colorized_action = fmt::format(fmt::emphasis::bold, "{}", ucl_object_tostring(elt)); break; } diff --git a/src/libmime/lang_detection_fasttext.cxx b/src/libmime/lang_detection_fasttext.cxx index faa97b0fc..89916151f 100644 --- a/src/libmime/lang_detection_fasttext.cxx +++ b/src/libmime/lang_detection_fasttext.cxx @@ -1,5 +1,5 @@ /* - * Copyright 2023 Vsevolod Stakhov + * Copyright 2024 Vsevolod Stakhov * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -20,7 +20,7 @@ #include "fasttext/fasttext.h" #include "libserver/cfg_file.h" #include "libserver/logger.h" -#include "fmt/core.h" +#include "fmt/base.h" #include "stat_api.h" #include <exception> #include <string_view> diff --git a/src/libserver/backtrace.cxx b/src/libserver/backtrace.cxx index 6507b964e..c24e61936 100644 --- a/src/libserver/backtrace.cxx +++ b/src/libserver/backtrace.cxx @@ -1,5 +1,5 @@ /* - * Copyright 2023 Vsevolod Stakhov + * Copyright 2024 Vsevolod Stakhov * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -19,7 +19,7 @@ #ifdef BACKWARD_ENABLE #include "contrib/backward-cpp/backward.hpp" -#include "fmt/core.h" +#include "fmt/base.h" #include "logger.h" namespace rspamd { diff --git a/src/libserver/cfg_rcl.cxx b/src/libserver/cfg_rcl.cxx index f0c9db64d..ce3df4010 100644 --- a/src/libserver/cfg_rcl.cxx +++ b/src/libserver/cfg_rcl.cxx @@ -34,7 +34,7 @@ #include <algorithm>// for std::transform #include <memory> #include "contrib/ankerl/unordered_dense.h" -#include "fmt/core.h" +#include "fmt/base.h" #include "libutil/cxx/util.hxx" #include "libutil/cxx/file_util.hxx" #include "frozen/unordered_set.h" diff --git a/src/libserver/cfg_utils.cxx b/src/libserver/cfg_utils.cxx index ff432ec4a..dd85eddfb 100644 --- a/src/libserver/cfg_utils.cxx +++ b/src/libserver/cfg_utils.cxx @@ -1,5 +1,5 @@ /* - * Copyright 2023 Vsevolod Stakhov + * Copyright 2024 Vsevolod Stakhov * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -65,7 +65,7 @@ #include <string> #include <string_view> #include <vector> -#include "fmt/core.h" +#include "fmt/base.h" #include "cxx/util.hxx" #include "frozen/unordered_map.h" #include "frozen/string.h" diff --git a/src/libserver/css/css_parser.cxx b/src/libserver/css/css_parser.cxx index aed035aa4..11fa830f0 100644 --- a/src/libserver/css/css_parser.cxx +++ b/src/libserver/css/css_parser.cxx @@ -1,11 +1,11 @@ -/*- - * Copyright 2021 Vsevolod Stakhov +/* + * Copyright 2024 Vsevolod Stakhov * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * - * http://www.apache.org/licenses/LICENSE-2.0 + * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, @@ -20,7 +20,7 @@ #include "css_rule.hxx" #include "css_util.hxx" #include "css.hxx" -#include "fmt/core.h" +#include "fmt/base.h" #include <vector> #include <unicode/utf8.h> diff --git a/src/libserver/css/css_selector.cxx b/src/libserver/css/css_selector.cxx index a62ffff9c..d2ae093cb 100644 --- a/src/libserver/css/css_selector.cxx +++ b/src/libserver/css/css_selector.cxx @@ -1,11 +1,11 @@ -/*- - * Copyright 2021 Vsevolod Stakhov +/* + * Copyright 2024 Vsevolod Stakhov * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * - * http://www.apache.org/licenses/LICENSE-2.0 + * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, @@ -17,7 +17,7 @@ #include "css_selector.hxx" #include "css.hxx" #include "libserver/html/html.hxx" -#include "fmt/core.h" +#include "fmt/base.h" #define DOCTEST_CONFIG_IMPLEMENTATION_IN_DLL #include "doctest/doctest.h" diff --git a/src/libserver/css/css_value.cxx b/src/libserver/css/css_value.cxx index 2546e0159..f2ff55363 100644 --- a/src/libserver/css/css_value.cxx +++ b/src/libserver/css/css_value.cxx @@ -1,11 +1,11 @@ -/*- - * Copyright 2021 Vsevolod Stakhov +/* + * Copyright 2024 Vsevolod Stakhov * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * - * http://www.apache.org/licenses/LICENSE-2.0 + * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, @@ -20,7 +20,7 @@ #include "frozen/string.h" #include "libutil/util.h" #include "contrib/ankerl/unordered_dense.h" -#include "fmt/core.h" +#include "fmt/base.h" #define DOCTEST_CONFIG_IMPLEMENTATION_IN_DLL #include "doctest/doctest.h" diff --git a/src/libserver/hyperscan_tools.cxx b/src/libserver/hyperscan_tools.cxx index 7d1ecf337..5035bee2c 100644 --- a/src/libserver/hyperscan_tools.cxx +++ b/src/libserver/hyperscan_tools.cxx @@ -1,5 +1,5 @@ /* - * Copyright 2023 Vsevolod Stakhov + * Copyright 2024 Vsevolod Stakhov * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -21,7 +21,7 @@ #include <filesystem> #include "contrib/ankerl/unordered_dense.h" #include "contrib/ankerl/svector.h" -#include "fmt/core.h" +#include "fmt/base.h" #include "libutil/cxx/file_util.hxx" #include "libutil/cxx/error.hxx" #include "hs.h" diff --git a/src/libserver/symcache/symcache_impl.cxx b/src/libserver/symcache/symcache_impl.cxx index 4ea087024..7159555d2 100644 --- a/src/libserver/symcache/symcache_impl.cxx +++ b/src/libserver/symcache/symcache_impl.cxx @@ -21,7 +21,7 @@ #include "unix-std.h" #include "libutil/cxx/file_util.hxx" #include "libutil/cxx/util.hxx" -#include "fmt/core.h" +#include "fmt/base.h" #include "contrib/t1ha/t1ha.h" #ifdef __has_include diff --git a/src/libserver/symcache/symcache_item.cxx b/src/libserver/symcache/symcache_item.cxx index 490a87880..4a9581fe7 100644 --- a/src/libserver/symcache/symcache_item.cxx +++ b/src/libserver/symcache/symcache_item.cxx @@ -17,7 +17,7 @@ #include "lua/lua_common.h" #include "symcache_internal.hxx" #include "symcache_item.hxx" -#include "fmt/core.h" +#include "fmt/base.h" #include "libserver/task.h" #include "libutil/cxx/util.hxx" #include <numeric> diff --git a/src/libstat/backends/cdb_backend.cxx b/src/libstat/backends/cdb_backend.cxx index 7bdbcb394..bd05e8ef8 100644 --- a/src/libstat/backends/cdb_backend.cxx +++ b/src/libstat/backends/cdb_backend.cxx @@ -1,11 +1,11 @@ -/*- - * Copyright 2021 Vsevolod Stakhov +/* + * Copyright 2024 Vsevolod Stakhov * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * - * http://www.apache.org/licenses/LICENSE-2.0 + * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, @@ -28,7 +28,7 @@ #include <optional> #include "contrib/expected/expected.hpp" #include "contrib/ankerl/unordered_dense.h" -#include "fmt/core.h" +#include "fmt/base.h" namespace rspamd::stat::cdb { diff --git a/src/libstat/backends/redis_backend.cxx b/src/libstat/backends/redis_backend.cxx index 6abcfa122..06842b078 100644 --- a/src/libstat/backends/redis_backend.cxx +++ b/src/libstat/backends/redis_backend.cxx @@ -19,7 +19,7 @@ #include "stat_internal.h" #include "upstream.h" #include "libserver/mempool_vars_internal.h" -#include "fmt/core.h" +#include "fmt/base.h" #include "libutil/cxx/error.hxx" diff --git a/test/rspamd_cxx_unit_dkim.hxx b/test/rspamd_cxx_unit_dkim.hxx index 3f6b71a39..d445c3800 100644 --- a/test/rspamd_cxx_unit_dkim.hxx +++ b/test/rspamd_cxx_unit_dkim.hxx @@ -1,11 +1,11 @@ -/*- - * Copyright 2021 Vsevolod Stakhov +/* + * Copyright 2024 Vsevolod Stakhov * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * - * http://www.apache.org/licenses/LICENSE-2.0 + * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, @@ -21,7 +21,7 @@ #define DOCTEST_CONFIG_IMPLEMENTATION_IN_DLL #include "doctest/doctest.h" -#include "fmt/core.h" +#include "fmt/base.h" #include "libserver/dkim.h" #include <vector> |