| // Copyright 2022 the V8 project authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #ifndef V8_BASE_STRING_FORMAT_H_ |
| #define V8_BASE_STRING_FORMAT_H_ |
| |
| #include <array> |
| #include <limits> |
| #include <string_view> |
| #include <tuple> |
| |
| #include "src/base/logging.h" |
| #include "src/base/platform/platform.h" |
| |
| namespace v8::base { |
| |
| // Implementation detail, do not use outside this header. The public interface |
| // is below. |
| namespace impl { |
| |
| template <const std::string_view&... strs> |
| struct JoinedStringViews { |
| static constexpr auto JoinIntoNullTerminatedArray() noexcept { |
| constexpr size_t kArraySize = (1 + ... + strs.size()); |
| std::array<char, kArraySize> arr{}; |
| char* ptr = arr.data(); |
| for (auto str : std::initializer_list<std::string_view>{strs...}) { |
| for (auto c : str) *ptr++ = c; |
| } |
| *ptr++ = '\0'; |
| DCHECK_EQ(arr.data() + arr.size(), ptr); |
| return arr; |
| } |
| |
| // Store in an array with static linkage, so we can reference it from the |
| // {std::string_view} below. |
| static constexpr auto array = JoinIntoNullTerminatedArray(); |
| |
| // Create a string view to the null-terminated array. The null byte is not |
| // included. |
| static constexpr std::string_view string_view = {array.data(), |
| array.size() - 1}; |
| }; |
| |
| template <typename T> |
| struct FormattedStringPart { |
| static_assert(sizeof(T) < 0, |
| "unimplemented type, add specialization below if needed"); |
| }; |
| |
| template <> |
| struct FormattedStringPart<int> { |
| // Integer range: [-2147483647, 2147483647]. Representable in 11 characters. |
| static constexpr int kMaxLen = 11; |
| static constexpr std::string_view kFormatPart = "%d"; |
| |
| int value; |
| }; |
| |
| template <> |
| struct FormattedStringPart<size_t> { |
| // size_t range: [0, 4294967295] on 32-bit, [0, +18446744073709551615] on |
| // 64-bit. Needs 10 or 20 characters. |
| static constexpr int kMaxLen = sizeof(size_t) == sizeof(uint32_t) ? 10 : 20; |
| static constexpr std::string_view kFormatPart = "%zu"; |
| |
| size_t value; |
| }; |
| |
| template <size_t N> |
| struct FormattedStringPart<char[N]> { |
| static_assert(N >= 1, "Do not print (static) empty strings"); |
| static_assert(N <= 128, "Do not include huge strings"); |
| static constexpr int kMaxLen = N - 1; |
| static constexpr std::string_view kFormatPart = "%s"; |
| |
| const char* value; |
| }; |
| |
| template <const std::string_view& kFormat, int kMaxLen, typename... Parts> |
| std::array<char, kMaxLen> PrintFormattedStringToArray(Parts... parts) { |
| std::array<char, kMaxLen> message; |
| |
| static_assert(kMaxLen > 0); |
| static_assert( |
| kMaxLen < 128, |
| "Don't generate overly large strings; this limit can be increased, but " |
| "consider that the array lives on the stack of the caller."); |
| |
| // Add a special case for empty strings, because compilers complain about |
| // empty format strings. |
| static_assert((kFormat.size() == 0) == (sizeof...(Parts) == 0)); |
| if constexpr (kFormat.size() == 0) { |
| message[0] = '\0'; |
| } else { |
| int characters = base::OS::SNPrintF(message.data(), kMaxLen, kFormat.data(), |
| parts.value...); |
| CHECK(characters >= 0 && characters < kMaxLen); |
| DCHECK_EQ('\0', message[characters]); |
| } |
| |
| return message; |
| } |
| |
| } // namespace impl |
| |
| // `FormattedString` allows to format strings with statically known number and |
| // type of constituents. |
| // The class stores all values that should be printed, and generates the final |
| // string via `SNPrintF` into a `std::array`, without any dynamic memory |
| // allocation. The format string is computed statically. |
| // This makes this class not only very performant, but also suitable for |
| // situations where we do not want to perform any memory allocation (like for |
| // reporting OOM or fatal errors). |
| // |
| // Use like this: |
| // auto message = FormattedString{} << "Cannot allocate " << size << " bytes"; |
| // V8::FatalProcessOutOfMemory(nullptr, message.PrintToArray().data()); |
| // |
| // This code is compiled into the equivalent of |
| // std::array<char, 34> message_arr; |
| // int chars = SNPrintF(message_arr.data(), 34, "%s%d%s", "Cannot allocate ", |
| // size, " bytes"); |
| // CHECK(chars >= 0 && chars < 34); |
| // V8::FatalProcessOutOfMemory(nullptr, message_arr.data()); |
| template <typename... Ts> |
| class FormattedString { |
| template <typename T> |
| using Part = impl::FormattedStringPart<T>; |
| |
| static_assert(std::conjunction_v<std::is_trivial<Part<Ts>>...>, |
| "All parts needs to be trivial to guarantee optimal code"); |
| |
| public: |
| static constexpr int kMaxLen = (1 + ... + Part<Ts>::kMaxLen); |
| static constexpr std::string_view kFormat = |
| impl::JoinedStringViews<Part<Ts>::kFormatPart...>::string_view; |
| |
| FormattedString() { |
| static_assert(sizeof...(Ts) == 0, |
| "Only explicitly construct empty FormattedString, use " |
| "operator<< to appending"); |
| } |
| |
| // Add one more part to the FormattedString. Only allowed on r-value ref (i.e. |
| // temporary object) to avoid misuse like `FormattedString<> str; str << 3;` |
| // instead of `auto str = FormattedString{} << 3;`. |
| template <typename T> |
| V8_WARN_UNUSED_RESULT auto operator<<(T&& t) const&& { |
| using PlainT = std::remove_cv_t<std::remove_reference_t<T>>; |
| return FormattedString<Ts..., PlainT>{ |
| std::tuple_cat(parts_, std::make_tuple(Part<PlainT>{t}))}; |
| } |
| |
| // Print this FormattedString into an array. Does not allocate any dynamic |
| // memory. The result lives on the stack of the caller. |
| V8_INLINE V8_WARN_UNUSED_RESULT std::array<char, kMaxLen> PrintToArray() |
| const { |
| return std::apply( |
| impl::PrintFormattedStringToArray<kFormat, kMaxLen, Part<Ts>...>, |
| parts_); |
| } |
| |
| private: |
| template <typename... Us> |
| friend class FormattedString; |
| |
| explicit FormattedString(std::tuple<Part<Ts>...> parts) : parts_(parts) {} |
| |
| std::tuple<Part<Ts>...> parts_; |
| }; |
| |
| // Add an explicit deduction guide for empty template parameters (fixes |
| // clang's -Wctad-maybe-unsupported warning). Non-empty formatted strings |
| // explicitly declare template parameters anyway. |
| FormattedString()->FormattedString<>; |
| |
| } // namespace v8::base |
| |
| #endif // V8_BASE_STRING_FORMAT_H_ |