Formatting library for C++
Copyright (c) 2012 - present, Victor Zverovich
- All rights reserved.
-
- Redistribution and use in source and binary forms, with or without
- modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice, this
- list of conditions and the following disclaimer.
- 2. Redistributions in binary form must reproduce the above copyright notice,
- this list of conditions and the following disclaimer in the documentation
- and/or other materials provided with the distribution.
-
- THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
- ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
- ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+ Permission is hereby granted, free of charge, to any person obtaining
+ a copy of this software and associated documentation files (the
+ "Software"), to deal in the Software without restriction, including
+ without limitation the rights to use, copy, modify, merge, publish,
+ distribute, sublicense, and/or sell copies of the Software, and to
+ permit persons to whom the Software is furnished to do so, subject to
+ the following conditions:
+
+ The above copyright notice and this permission notice shall be
+ included in all copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+ --- Optional exception to the license ---
+
+ As an exception, if, as a result of your compiling your source code, portions
+ of this Software are embedded into a machine-executable object form of such
+ source code, you may redistribute such embedded portions in such object form
+ without including the above copyright and permission notices.
*/
#ifndef FMT_FORMAT_H_
#define FMT_FORMAT_H_
-#include <stdint.h>
#include <algorithm>
-#include <cassert>
+#include <cerrno>
#include <cmath>
-#include <cstring>
+#include <cstdint>
#include <limits>
#include <memory>
#include <stdexcept>
-#ifdef __clang__
-# define FMT_CLANG_VERSION (__clang_major__ * 100 + __clang_minor__)
-#else
-# define FMT_CLANG_VERSION 0
-#endif
+#include "core.h"
#ifdef __INTEL_COMPILER
# define FMT_ICC_VERSION __INTEL_COMPILER
# define FMT_CUDA_VERSION 0
#endif
-#include "core.h"
-
-#if FMT_GCC_VERSION >= 406 || FMT_CLANG_VERSION
-# pragma GCC diagnostic push
-
-// Disable warning about not handling all enums in switch statement even with
-// a default case
-# pragma GCC diagnostic ignored "-Wswitch-enum"
-
-// Disable the warning about declaration shadowing because it affects too
-// many valid cases.
-# pragma GCC diagnostic ignored "-Wshadow"
-
-// Disable the warning about nonliteral format strings because we construct
-// them dynamically when falling back to snprintf for FP formatting.
-# pragma GCC diagnostic ignored "-Wformat-nonliteral"
-#endif
-
-#if FMT_CLANG_VERSION
-# pragma GCC diagnostic ignored "-Wgnu-string-literal-operator-template"
+#ifdef __has_builtin
+# define FMT_HAS_BUILTIN(x) __has_builtin(x)
+#else
+# define FMT_HAS_BUILTIN(x) 0
#endif
-#ifdef _SECURE_SCL
-# define FMT_SECURE_SCL _SECURE_SCL
+#if FMT_GCC_VERSION || FMT_CLANG_VERSION
+# define FMT_NOINLINE __attribute__((noinline))
#else
-# define FMT_SECURE_SCL 0
+# define FMT_NOINLINE
#endif
-// Check whether we can use unrestricted unions and use struct if not.
-#ifndef FMT_UNRESTRICTED_UNION
-# if FMT_MSC_VER >= 1900 || FMT_GCC_VERSION >= 406 || FMT_CLANG_VERSION >= 303
-# define FMT_UNRESTRICTED_UNION union
+#if __cplusplus == 201103L || __cplusplus == 201402L
+# if defined(__clang__)
+# define FMT_FALLTHROUGH [[clang::fallthrough]]
+# elif FMT_GCC_VERSION >= 700 && !defined(__PGI)
+# define FMT_FALLTHROUGH [[gnu::fallthrough]]
# else
-# define FMT_UNRESTRICTED_UNION struct
+# define FMT_FALLTHROUGH
# endif
-#endif
-
-#if FMT_SECURE_SCL
-# include <iterator>
-#endif
-
-#ifdef __has_builtin
-# define FMT_HAS_BUILTIN(x) __has_builtin(x)
+#elif FMT_HAS_CPP17_ATTRIBUTE(fallthrough) || \
+ (defined(_MSVC_LANG) && _MSVC_LANG >= 201703L)
+# define FMT_FALLTHROUGH [[fallthrough]]
#else
-# define FMT_HAS_BUILTIN(x) 0
+# define FMT_FALLTHROUGH
#endif
-#ifdef __GNUC_LIBSTD__
-# define FMT_GNUC_LIBSTD_VERSION \
- (__GNUC_LIBSTD__ * 100 + __GNUC_LIBSTD_MINOR__)
+#ifndef FMT_MAYBE_UNUSED
+# if FMT_HAS_CPP17_ATTRIBUTE(maybe_unused)
+# define FMT_MAYBE_UNUSED [[maybe_unused]]
+# else
+# define FMT_MAYBE_UNUSED
+# endif
#endif
#ifndef FMT_THROW
# if FMT_EXCEPTIONS
-# if FMT_MSC_VER
+# if FMT_MSC_VER || FMT_NVCC
FMT_BEGIN_NAMESPACE
-namespace internal {
+namespace detail {
template <typename Exception> inline void do_throw(const Exception& x) {
- // Silence unreachable code warnings in MSVC because these are nearly
- // impossible to fix in a generic code.
+ // Silence unreachable code warnings in MSVC and NVCC because these
+ // are nearly impossible to fix in a generic code.
volatile bool b = true;
if (b) throw x;
}
-} // namespace internal
+} // namespace detail
FMT_END_NAMESPACE
-# define FMT_THROW(x) fmt::internal::do_throw(x)
+# define FMT_THROW(x) detail::do_throw(x)
# else
# define FMT_THROW(x) throw x
# endif
# define FMT_THROW(x) \
do { \
static_cast<void>(sizeof(x)); \
- assert(false); \
- } while (false);
+ FMT_ASSERT(false, ""); \
+ } while (false)
# 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_USE_USER_DEFINED_LITERALS
-// For Intel's compiler and NVIDIA's compiler both it and the system gcc/msc
-// must support UDLs.
+// For Intel and NVIDIA compilers both they and the system gcc/msc support UDLs.
# if (FMT_HAS_FEATURE(cxx_user_literals) || FMT_GCC_VERSION >= 407 || \
FMT_MSC_VER >= 1900) && \
(!(FMT_ICC_VERSION || FMT_CUDA_VERSION) || FMT_ICC_VERSION >= 1500 || \
# endif
#endif
-// EDG C++ Front End based compilers (icc, nvcc) do not currently support UDL
-// templates.
-#if FMT_USE_USER_DEFINED_LITERALS && FMT_ICC_VERSION == 0 && \
- FMT_CUDA_VERSION == 0 && \
- ((FMT_GCC_VERSION >= 600 && __cplusplus >= 201402L) || \
- (defined(FMT_CLANG_VERSION) && FMT_CLANG_VERSION >= 304))
-# define FMT_UDL_TEMPLATE 1
-#else
-# define FMT_UDL_TEMPLATE 0
-#endif
-
-#ifndef FMT_USE_EXTERN_TEMPLATES
-# ifndef FMT_HEADER_ONLY
-# define FMT_USE_EXTERN_TEMPLATES \
- ((FMT_CLANG_VERSION >= 209 && __cplusplus >= 201103L) || \
- (FMT_GCC_VERSION >= 303 && FMT_HAS_GXX_CXX11))
+#ifndef FMT_USE_UDL_TEMPLATE
+// EDG front end based compilers (icc, nvcc) and GCC < 6.4 do not propertly
+// support UDL templates and GCC >= 9 warns about them.
+# if FMT_USE_USER_DEFINED_LITERALS && FMT_ICC_VERSION == 0 && \
+ FMT_CUDA_VERSION == 0 && \
+ ((FMT_GCC_VERSION >= 604 && __cplusplus >= 201402L) || \
+ FMT_CLANG_VERSION >= 304)
+# define FMT_USE_UDL_TEMPLATE 1
# else
-# define FMT_USE_EXTERN_TEMPLATES 0
+# define FMT_USE_UDL_TEMPLATE 0
# endif
#endif
-#if FMT_HAS_GXX_CXX11 || FMT_HAS_FEATURE(cxx_trailing_return) || \
- FMT_MSC_VER >= 1600
-# define FMT_USE_TRAILING_RETURN 1
-#else
-# define FMT_USE_TRAILING_RETURN 0
+#ifndef FMT_USE_FLOAT
+# define FMT_USE_FLOAT 1
+#endif
+
+#ifndef FMT_USE_DOUBLE
+# define FMT_USE_DOUBLE 1
+#endif
+
+#ifndef FMT_USE_LONG_DOUBLE
+# define FMT_USE_LONG_DOUBLE 1
#endif
// __builtin_clz is broken in clang with Microsoft CodeGen:
// https://github.com/fmtlib/fmt/issues/519
-#ifndef _MSC_VER
-# if FMT_GCC_VERSION >= 400 || FMT_HAS_BUILTIN(__builtin_clz)
-# define FMT_BUILTIN_CLZ(n) __builtin_clz(n)
-# endif
-
-# if FMT_GCC_VERSION >= 400 || FMT_HAS_BUILTIN(__builtin_clzll)
-# define FMT_BUILTIN_CLZLL(n) __builtin_clzll(n)
-# endif
+#if (FMT_GCC_VERSION || FMT_HAS_BUILTIN(__builtin_clz)) && !FMT_MSC_VER
+# define FMT_BUILTIN_CLZ(n) __builtin_clz(n)
+#endif
+#if (FMT_GCC_VERSION || FMT_HAS_BUILTIN(__builtin_clzll)) && !FMT_MSC_VER
+# define FMT_BUILTIN_CLZLL(n) __builtin_clzll(n)
#endif
// Some compilers masquerade as both MSVC and GCC-likes or otherwise support
# include <intrin.h> // _BitScanReverse, _BitScanReverse64
FMT_BEGIN_NAMESPACE
-namespace internal {
+namespace detail {
// Avoid Clang with Microsoft CodeGen's -Wunknown-pragmas warning.
# ifndef __clang__
# pragma intrinsic(_BitScanReverse)
unsigned long r = 0;
_BitScanReverse(&r, x);
- assert(x != 0);
+ FMT_ASSERT(x != 0, "");
// Static analysis complains about using uninitialized data
// "r", but the only way that can happen is if "x" is 0,
// which the callers guarantee to not happen.
-# pragma warning(suppress : 6102)
+ FMT_SUPPRESS_MSC_WARNING(6102)
return 31 - r;
}
-# define FMT_BUILTIN_CLZ(n) fmt::internal::clz(n)
+# define FMT_BUILTIN_CLZ(n) detail::clz(n)
# if defined(_WIN64) && !defined(__clang__)
# pragma intrinsic(_BitScanReverse64)
_BitScanReverse(&r, static_cast<uint32_t>(x));
# endif
- assert(x != 0);
+ FMT_ASSERT(x != 0, "");
// Static analysis complains about using uninitialized data
// "r", but the only way that can happen is if "x" is 0,
// which the callers guarantee to not happen.
-# pragma warning(suppress : 6102)
+ FMT_SUPPRESS_MSC_WARNING(6102)
return 63 - r;
}
-# define FMT_BUILTIN_CLZLL(n) fmt::internal::clzll(n)
-} // namespace internal
+# define FMT_BUILTIN_CLZLL(n) detail::clzll(n)
+} // namespace detail
FMT_END_NAMESPACE
#endif
-FMT_BEGIN_NAMESPACE
-namespace internal {
-
-#ifndef FMT_USE_GRISU
-# define FMT_USE_GRISU 1
+// Enable the deprecated numeric alignment.
+#ifndef FMT_NUMERIC_ALIGN
+# define FMT_NUMERIC_ALIGN 1
#endif
-template <typename T> inline bool use_grisu() {
- return FMT_USE_GRISU && std::numeric_limits<double>::is_iec559 &&
- sizeof(T) <= sizeof(double);
-}
+FMT_BEGIN_NAMESPACE
+namespace detail {
-// An equivalent of `*reinterpret_cast<Dest*>(&source)` that doesn't produce
+// An equivalent of `*reinterpret_cast<Dest*>(&source)` that doesn't have
// undefined behavior (e.g. due to type aliasing).
// Example: uint64_t d = bit_cast<uint64_t>(2.718);
template <typename Dest, typename Source>
return dest;
}
-// An implementation of begin and end for pre-C++11 compilers such as gcc 4.
-template <typename C>
-FMT_CONSTEXPR auto begin(const C& c) -> decltype(c.begin()) {
- return c.begin();
+inline bool is_big_endian() {
+ const auto u = 1u;
+ struct bytes {
+ char data[sizeof(u)];
+ };
+ return bit_cast<bytes>(u).data[0] == 0;
+}
+
+// A fallback implementation of uintptr_t for systems that lack it.
+struct fallback_uintptr {
+ unsigned char value[sizeof(void*)];
+
+ fallback_uintptr() = default;
+ explicit fallback_uintptr(const void* p) {
+ *this = bit_cast<fallback_uintptr>(p);
+ if (is_big_endian()) {
+ for (size_t i = 0, j = sizeof(void*) - 1; i < j; ++i, --j)
+ std::swap(value[i], value[j]);
+ }
+ }
+};
+#ifdef UINTPTR_MAX
+using uintptr_t = ::uintptr_t;
+inline uintptr_t to_uintptr(const void* p) { return bit_cast<uintptr_t>(p); }
+#else
+using uintptr_t = fallback_uintptr;
+inline fallback_uintptr to_uintptr(const void* p) {
+ return fallback_uintptr(p);
}
-template <typename T, std::size_t N>
-FMT_CONSTEXPR T* begin(T (&array)[N]) FMT_NOEXCEPT {
- return array;
+#endif
+
+// Returns the largest possible value for type T. Same as
+// std::numeric_limits<T>::max() but shorter and not affected by the max macro.
+template <typename T> constexpr T max_value() {
+ return (std::numeric_limits<T>::max)();
}
-template <typename C> FMT_CONSTEXPR auto end(const C& c) -> decltype(c.end()) {
- return c.end();
+template <typename T> constexpr int num_bits() {
+ return std::numeric_limits<T>::digits;
}
-template <typename T, std::size_t N>
-FMT_CONSTEXPR T* end(T (&array)[N]) FMT_NOEXCEPT {
- return array + N;
+template <> constexpr int num_bits<fallback_uintptr>() {
+ return static_cast<int>(sizeof(void*) *
+ std::numeric_limits<unsigned char>::digits);
+}
+
+FMT_INLINE void assume(bool condition) {
+ (void)condition;
+#if FMT_HAS_BUILTIN(__builtin_assume)
+ __builtin_assume(condition);
+#endif
}
-// For std::result_of in gcc 4.4.
-template <typename Result> struct function {
- template <typename T> struct result { typedef Result type; };
+// A workaround for gcc 4.8 to make void_t work in a SFINAE context.
+template <typename... Ts> struct void_t_impl { using type = void; };
+
+template <typename... Ts>
+using void_t = typename detail::void_t_impl<Ts...>::type;
+
+// An approximation of iterator_t for pre-C++20 systems.
+template <typename T>
+using iterator_t = decltype(std::begin(std::declval<T&>()));
+template <typename T> using sentinel_t = decltype(std::end(std::declval<T&>()));
+
+// Detect the iterator category of *any* given type in a SFINAE-friendly way.
+// Unfortunately, older implementations of std::iterator_traits are not safe
+// for use in a SFINAE-context.
+template <typename It, typename Enable = void>
+struct iterator_category : std::false_type {};
+
+template <typename T> struct iterator_category<T*> {
+ using type = std::random_access_iterator_tag;
+};
+
+template <typename It>
+struct iterator_category<It, void_t<typename It::iterator_category>> {
+ using type = typename It::iterator_category;
+};
+
+// Detect if *any* given type models the OutputIterator concept.
+template <typename It> class is_output_iterator {
+ // Check for mutability because all iterator categories derived from
+ // std::input_iterator_tag *may* also meet the requirements of an
+ // OutputIterator, thereby falling into the category of 'mutable iterators'
+ // [iterator.requirements.general] clause 4. The compiler reveals this
+ // property only at the point of *actually dereferencing* the iterator!
+ template <typename U>
+ static decltype(*(std::declval<U>())) test(std::input_iterator_tag);
+ template <typename U> static char& test(std::output_iterator_tag);
+ template <typename U> static const char& test(...);
+
+ using type = decltype(test<It>(typename iterator_category<It>::type{}));
+
+ public:
+ enum { value = !std::is_const<remove_reference_t<type>>::value };
};
-template <typename Allocator>
-typename Allocator::value_type* allocate(Allocator& alloc, std::size_t n) {
-#if __cplusplus >= 201103L || FMT_MSC_VER >= 1700
- return std::allocator_traits<Allocator>::allocate(alloc, n);
+// A workaround for std::string not having mutable data() until C++17.
+template <typename Char> inline Char* get_data(std::basic_string<Char>& s) {
+ return &s[0];
+}
+template <typename Container>
+inline typename Container::value_type* get_data(Container& c) {
+ 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> checked_ptr<T> make_checked(T* p, size_t size) {
+ return {p, size};
+}
#else
- return alloc.allocate(n);
+template <typename T> using checked_ptr = T*;
+template <typename T> inline T* make_checked(T* p, size_t) { return p; }
+#endif
+
+template <typename Container, FMT_ENABLE_IF(is_contiguous<Container>::value)>
+#if FMT_CLANG_VERSION
+__attribute__((no_sanitize("undefined")))
#endif
+inline checked_ptr<typename Container::value_type>
+reserve(std::back_insert_iterator<Container> it, size_t n) {
+ Container& c = get_container(it);
+ size_t size = c.size();
+ c.resize(size + n);
+ return make_checked(get_data(c) + size, n);
}
-} // namespace internal
-FMT_END_NAMESPACE
-FMT_BEGIN_NAMESPACE
-template <typename Range> class basic_writer;
+template <typename Iterator> inline Iterator& reserve(Iterator& it, size_t) {
+ return it;
+}
-template <typename OutputIt, typename T = typename OutputIt::value_type>
-class output_range {
- private:
- OutputIt it_;
+template <typename Container, FMT_ENABLE_IF(is_contiguous<Container>::value)>
+inline std::back_insert_iterator<Container> base_iterator(
+ std::back_insert_iterator<Container>& it,
+ checked_ptr<typename Container::value_type>) {
+ return it;
+}
+
+template <typename Iterator>
+inline Iterator base_iterator(Iterator, Iterator it) {
+ return it;
+}
- // Unused yet.
- typedef void sentinel;
- sentinel end() const;
+// An output iterator that counts the number of objects written to it and
+// discards them.
+class counting_iterator {
+ private:
+ size_t count_;
public:
- typedef OutputIt iterator;
- typedef T value_type;
+ using iterator_category = std::output_iterator_tag;
+ using difference_type = std::ptrdiff_t;
+ using pointer = void;
+ using reference = void;
+ using _Unchecked_type = counting_iterator; // Mark iterator as checked.
+
+ struct value_type {
+ template <typename T> void operator=(const T&) {}
+ };
- explicit output_range(OutputIt it) : it_(it) {}
- OutputIt begin() const { return it_; }
+ counting_iterator() : count_(0) {}
+
+ size_t count() const { return count_; }
+
+ counting_iterator& operator++() {
+ ++count_;
+ return *this;
+ }
+
+ counting_iterator operator++(int) {
+ auto it = *this;
+ ++*this;
+ return it;
+ }
+
+ value_type operator*() const { return {}; }
};
-// A range where begin() returns back_insert_iterator.
-template <typename Container>
-class back_insert_range
- : public output_range<std::back_insert_iterator<Container>> {
- typedef output_range<std::back_insert_iterator<Container>> base;
+template <typename OutputIt> class truncating_iterator_base {
+ protected:
+ OutputIt out_;
+ size_t limit_;
+ size_t count_;
+
+ truncating_iterator_base(OutputIt out, size_t limit)
+ : out_(out), limit_(limit), count_(0) {}
public:
- typedef typename Container::value_type value_type;
+ using iterator_category = std::output_iterator_tag;
+ using value_type = typename std::iterator_traits<OutputIt>::value_type;
+ using difference_type = void;
+ using pointer = void;
+ using reference = void;
+ using _Unchecked_type =
+ truncating_iterator_base; // Mark iterator as checked.
- back_insert_range(Container& c) : base(std::back_inserter(c)) {}
- back_insert_range(typename base::iterator it) : base(it) {}
+ OutputIt base() const { return out_; }
+ size_t count() const { return count_; }
};
-typedef basic_writer<back_insert_range<internal::buffer>> writer;
-typedef basic_writer<back_insert_range<internal::wbuffer>> wwriter;
+// 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_;
-/** A formatting error such as invalid format string. */
-class format_error : public std::runtime_error {
public:
- explicit format_error(const char* message) : std::runtime_error(message) {}
+ using value_type = typename truncating_iterator_base<OutputIt>::value_type;
- explicit format_error(const std::string& message)
- : std::runtime_error(message) {}
+ 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(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; }
};
-namespace internal {
+// A range with the specified output iterator and value type.
+template <typename OutputIt, typename T = typename OutputIt::value_type>
+class output_range {
+ private:
+ OutputIt it_;
+
+ public:
+ using value_type = T;
+ using iterator = OutputIt;
+ struct sentinel {};
-#if FMT_SECURE_SCL
-template <typename T> struct checked {
- typedef stdext::checked_array_iterator<T*> type;
+ explicit output_range(OutputIt it) : it_(it) {}
+ OutputIt begin() const { return it_; }
+ sentinel end() const { return {}; } // Sentinel is not used yet.
};
-// Make a checked iterator to avoid warnings on MSVC.
-template <typename T>
-inline stdext::checked_array_iterator<T*> make_checked(T* p, std::size_t size) {
- return {p, size};
+template <typename Char>
+inline size_t count_code_points(basic_string_view<Char> s) {
+ return s.size();
}
-#else
-template <typename T> struct checked { typedef T* type; };
-template <typename T> inline T* make_checked(T* p, std::size_t) { return p; }
+
+// Counts the number of code points in a UTF-8 string.
+inline size_t count_code_points(basic_string_view<char> s) {
+ 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;
+ }
+ return num_code_points;
+}
+
+inline size_t count_code_points(basic_string_view<char8_type> s) {
+ return count_code_points(basic_string_view<char>(
+ reinterpret_cast<const char*>(s.data()), s.size()));
+}
+
+template <typename Char>
+inline size_t code_point_index(basic_string_view<Char> s, size_t n) {
+ size_t size = s.size();
+ return n < size ? n : size;
+}
+
+// Calculates the index of the nth code point in a UTF-8 string.
+inline size_t code_point_index(basic_string_view<char8_type> s, size_t n) {
+ const char8_type* 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 char8_type to_char8_t(char c) { return static_cast<char8_type>(c); }
+
+template <typename InputIt, typename OutChar>
+using needs_conversion = bool_constant<
+ std::is_same<typename std::iterator_traits<InputIt>::value_type,
+ char>::value &&
+ std::is_same<OutChar, char8_type>::value>;
+
+template <typename OutChar, typename InputIt, typename OutputIt,
+ FMT_ENABLE_IF(!needs_conversion<InputIt, OutChar>::value)>
+OutputIt copy_str(InputIt begin, InputIt end, OutputIt it) {
+ return std::copy(begin, end, it);
+}
+
+template <typename OutChar, typename InputIt, typename OutputIt,
+ FMT_ENABLE_IF(needs_conversion<InputIt, OutChar>::value)>
+OutputIt copy_str(InputIt begin, InputIt end, OutputIt it) {
+ return std::transform(begin, end, it, to_char8_t);
+}
+
+#ifndef FMT_USE_GRISU
+# define FMT_USE_GRISU 1
#endif
+template <typename T> constexpr bool use_grisu() {
+ return FMT_USE_GRISU && std::numeric_limits<double>::is_iec559 &&
+ sizeof(T) <= sizeof(double);
+}
+
template <typename T>
template <typename U>
-void basic_buffer<T>::append(const U* begin, const U* end) {
- std::size_t new_size = size_ + internal::to_unsigned(end - begin);
+void buffer<T>::append(const U* begin, const U* end) {
+ size_t new_size = size_ + to_unsigned(end - begin);
reserve(new_size);
- std::uninitialized_copy(begin, end,
- internal::make_checked(ptr_, capacity_) + size_);
+ std::uninitialized_copy(begin, end, make_checked(ptr_, capacity_) + size_);
size_ = new_size;
}
-} // namespace internal
-
-// C++20 feature test, since r346892 Clang considers char8_t a fundamental
-// type in this mode. If this is the case __cpp_char8_t will be defined.
-#if !defined(__cpp_char8_t)
-// A UTF-8 code unit type.
-enum char8_t : unsigned char {};
-#endif
+} // namespace detail
-// A UTF-8 string view.
-class u8string_view : public basic_string_view<char8_t> {
+// A range with an iterator appending to a buffer.
+template <typename T>
+class buffer_range
+ : public detail::output_range<std::back_insert_iterator<detail::buffer<T>>,
+ T> {
public:
- typedef char8_t char_type;
-
- u8string_view(const char* s)
- : basic_string_view<char8_t>(reinterpret_cast<const char8_t*>(s)) {}
- u8string_view(const char* s, size_t count) FMT_NOEXCEPT
- : basic_string_view<char8_t>(reinterpret_cast<const char8_t*>(s), count) {
- }
+ using iterator = std::back_insert_iterator<detail::buffer<T>>;
+ using detail::output_range<iterator, T>::output_range;
+ buffer_range(detail::buffer<T>& buf)
+ : detail::output_range<iterator, T>(std::back_inserter(buf)) {}
};
-#if FMT_USE_USER_DEFINED_LITERALS
-inline namespace literals {
-inline u8string_view operator"" _u(const char* s, std::size_t n) {
- return {s, n};
-}
-} // namespace literals
-#endif
-
// The number of characters to store in the basic_memory_buffer object itself
// to avoid dynamic memory allocation.
enum { inline_buffer_size = 500 };
A dynamically growing memory buffer for trivially copyable/constructible types
with the first ``SIZE`` elements stored in the object itself.
- You can use one of the following typedefs for common character types:
+ You can use one of the following type aliases for common character types:
+----------------+------------------------------+
| Type | Definition |
The output can be converted to an ``std::string`` with ``to_string(out)``.
\endrst
*/
-template <typename T, std::size_t SIZE = inline_buffer_size,
+template <typename T, size_t SIZE = inline_buffer_size,
typename Allocator = std::allocator<T>>
-class basic_memory_buffer : private Allocator,
- public internal::basic_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_;
+
// Deallocate memory allocated by the buffer.
void deallocate() {
T* data = this->data();
- if (data != store_) Allocator::deallocate(data, this->capacity());
+ if (data != store_) alloc_.deallocate(data, this->capacity());
}
protected:
- void grow(std::size_t size) FMT_OVERRIDE;
+ void grow(size_t size) FMT_OVERRIDE;
public:
- typedef T value_type;
- typedef const T& const_reference;
+ using value_type = T;
+ using const_reference = const T&;
explicit basic_memory_buffer(const Allocator& alloc = Allocator())
- : Allocator(alloc) {
+ : alloc_(alloc) {
this->set(store_, SIZE);
}
- ~basic_memory_buffer() { deallocate(); }
+ ~basic_memory_buffer() FMT_OVERRIDE { deallocate(); }
private:
// Move data from other to this buffer.
void move(basic_memory_buffer& other) {
- Allocator &this_alloc = *this, &other_alloc = other;
- this_alloc = std::move(other_alloc);
+ alloc_ = std::move(other.alloc_);
T* data = other.data();
- std::size_t size = other.size(), capacity = other.capacity();
+ size_t size = other.size(), capacity = other.capacity();
if (data == other.store_) {
this->set(store_, capacity);
std::uninitialized_copy(other.store_, other.store_ + size,
- internal::make_checked(store_, capacity));
+ detail::make_checked(store_, capacity));
} else {
this->set(data, capacity);
// Set pointer to the inline array so that delete is not called
of the other object to it.
\endrst
*/
- basic_memory_buffer(basic_memory_buffer&& other) { move(other); }
+ basic_memory_buffer(basic_memory_buffer&& other) FMT_NOEXCEPT { move(other); }
/**
\rst
Moves the content of the other ``basic_memory_buffer`` object to this one.
\endrst
*/
- basic_memory_buffer& operator=(basic_memory_buffer&& other) {
- assert(this != &other);
+ basic_memory_buffer& operator=(basic_memory_buffer&& other) FMT_NOEXCEPT {
+ FMT_ASSERT(this != &other, "");
deallocate();
move(other);
return *this;
}
// Returns a copy of the allocator associated with this buffer.
- Allocator get_allocator() const { return *this; }
+ Allocator get_allocator() const { return alloc_; }
};
-template <typename T, std::size_t SIZE, typename Allocator>
-void basic_memory_buffer<T, SIZE, Allocator>::grow(std::size_t size) {
- std::size_t old_capacity = this->capacity();
- std::size_t new_capacity = old_capacity + old_capacity / 2;
+template <typename T, size_t SIZE, typename Allocator>
+void basic_memory_buffer<T, SIZE, Allocator>::grow(size_t size) {
+#ifdef FMT_FUZZ
+ if (size > 5000) throw std::runtime_error("fuzz mode - won't grow that much");
+#endif
+ size_t old_capacity = this->capacity();
+ size_t new_capacity = old_capacity + old_capacity / 2;
if (size > new_capacity) new_capacity = size;
T* old_data = this->data();
- T* new_data = internal::allocate<Allocator>(*this, new_capacity);
+ T* new_data =
+ std::allocator_traits<Allocator>::allocate(alloc_, 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(),
- internal::make_checked(new_data, new_capacity));
+ detail::make_checked(new_data, new_capacity));
this->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_) Allocator::deallocate(old_data, old_capacity);
+ if (old_data != store_) alloc_.deallocate(old_data, old_capacity);
}
-typedef basic_memory_buffer<char> memory_buffer;
-typedef basic_memory_buffer<wchar_t> wmemory_buffer;
-
-namespace internal {
+using memory_buffer = basic_memory_buffer<char>;
+using wmemory_buffer = basic_memory_buffer<wchar_t>;
-template <typename Char> struct char_traits;
-
-template <> struct char_traits<char> {
- // Formats a floating-point number.
- template <typename T>
- FMT_API static int format_float(char* buffer, std::size_t size,
- const char* format, int precision, T value);
-};
-
-template <> struct char_traits<wchar_t> {
- template <typename T>
- FMT_API static int format_float(wchar_t* buffer, std::size_t size,
- const wchar_t* format, int precision,
- T value);
+/** A formatting error such as invalid format string. */
+FMT_CLASS_API
+class FMT_API format_error : public std::runtime_error {
+ public:
+ explicit format_error(const char* message) : std::runtime_error(message) {}
+ explicit format_error(const std::string& message)
+ : std::runtime_error(message) {}
+ format_error(const format_error&) = default;
+ format_error& operator=(const format_error&) = default;
+ format_error(format_error&&) = default;
+ format_error& operator=(format_error&&) = default;
+ ~format_error() FMT_NOEXCEPT FMT_OVERRIDE;
};
-#if FMT_USE_EXTERN_TEMPLATES
-extern template int char_traits<char>::format_float<double>(char* buffer,
- std::size_t size,
- const char* format,
- int precision,
- double value);
-extern template int char_traits<char>::format_float<long double>(
- char* buffer, std::size_t size, const char* format, int precision,
- long double value);
-
-extern template int char_traits<wchar_t>::format_float<double>(
- wchar_t* buffer, std::size_t size, const wchar_t* format, int precision,
- double value);
-extern template int char_traits<wchar_t>::format_float<long double>(
- wchar_t* buffer, std::size_t size, const wchar_t* format, int precision,
- long double value);
-#endif
-
-template <typename Container, FMT_ENABLE_IF(is_contiguous<Container>::value)>
-inline typename checked<typename Container::value_type>::type reserve(
- std::back_insert_iterator<Container>& it, std::size_t n) {
- Container& c = internal::get_container(it);
- std::size_t size = c.size();
- c.resize(size + n);
- return make_checked(&c[size], n);
-}
-
-template <typename Iterator>
-inline Iterator& reserve(Iterator& it, std::size_t) {
- return it;
-}
-
-template <typename Char> class null_terminating_iterator;
-
-template <typename Char>
-FMT_CONSTEXPR_DECL const Char* pointer_from(null_terminating_iterator<Char> it);
-
-// An output iterator that counts the number of objects written to it and
-// discards them.
-template <typename T> class counting_iterator {
- private:
- std::size_t count_;
- mutable T blackhole_;
-
- public:
- typedef std::output_iterator_tag iterator_category;
- typedef T value_type;
- typedef std::ptrdiff_t difference_type;
- typedef T* pointer;
- typedef T& reference;
- typedef counting_iterator _Unchecked_type; // Mark iterator as checked.
-
- counting_iterator() : count_(0) {}
-
- std::size_t count() const { return count_; }
-
- counting_iterator& operator++() {
- ++count_;
- return *this;
- }
-
- counting_iterator operator++(int) {
- auto it = *this;
- ++*this;
- return it;
- }
-
- T& operator*() const { return blackhole_; }
-};
-
-template <typename OutputIt> class truncating_iterator_base {
- protected:
- OutputIt out_;
- std::size_t limit_;
- std::size_t count_;
-
- truncating_iterator_base(OutputIt out, std::size_t limit)
- : out_(out), limit_(limit), count_(0) {}
-
- public:
- typedef std::output_iterator_tag iterator_category;
- typedef void difference_type;
- typedef void pointer;
- typedef void reference;
- typedef truncating_iterator_base
- _Unchecked_type; // Mark iterator as checked.
-
- OutputIt base() const { return out_; }
- std::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> {
- typedef std::iterator_traits<OutputIt> traits;
-
- mutable typename traits::value_type blackhole_;
-
- public:
- typedef typename traits::value_type value_type;
-
- truncating_iterator(OutputIt out, std::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:
- typedef typename OutputIt::container_type::value_type value_type;
-
- truncating_iterator(OutputIt out, std::size_t limit)
- : truncating_iterator_base<OutputIt>(out, limit) {}
-
- truncating_iterator& operator=(value_type 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; }
-};
+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.
+// Same as `value < 0` but doesn't produce warnings if T is an unsigned type.
template <typename T, FMT_ENABLE_IF(std::numeric_limits<T>::is_signed)>
FMT_CONSTEXPR bool is_negative(T value) {
return value < 0;
return false;
}
-template <typename T> struct int_traits {
- // Smallest of uint32_t and uint64_t that is large enough to represent
- // all values of T.
- typedef typename std::conditional<std::numeric_limits<T>::digits <= 32,
- uint32_t, uint64_t>::type main_type;
-};
-
-// Static data is placed in this class template to allow header-only
-// configuration.
-template <typename T = void> struct FMT_API basic_data {
- static const uint64_t POWERS_OF_10_64[];
- static const uint32_t ZERO_OR_POWERS_OF_10_32[];
- static const uint64_t ZERO_OR_POWERS_OF_10_64[];
- static const uint64_t POW10_SIGNIFICANDS[];
- static const int16_t POW10_EXPONENTS[];
- static const char DIGITS[];
- static const char FOREGROUND_COLOR[];
- static const char BACKGROUND_COLOR[];
- static const char RESET_COLOR[5];
- static const wchar_t WRESET_COLOR[5];
-};
-
-#if FMT_USE_EXTERN_TEMPLATES
-extern template struct basic_data<void>;
-#endif
+template <typename T, FMT_ENABLE_IF(std::is_floating_point<T>::value)>
+FMT_CONSTEXPR bool is_supported_floating_point(T) {
+ return (std::is_same<T, float>::value && FMT_USE_FLOAT) ||
+ (std::is_same<T, double>::value && FMT_USE_DOUBLE) ||
+ (std::is_same<T, long double>::value && FMT_USE_LONG_DOUBLE);
+}
-typedef basic_data<> data;
+// Smallest of uint32_t, uint64_t, uint128_t that is large enough to
+// represent all values of T.
+template <typename T>
+using uint32_or_64_or_128_t = conditional_t<
+ std::numeric_limits<T>::digits <= 32, uint32_t,
+ conditional_t<std::numeric_limits<T>::digits <= 64, uint64_t, uint128_t>>;
+
+// Static data is placed in this class template for the header-only config.
+template <typename T = void> struct FMT_EXTERN_TEMPLATE_API basic_data {
+ static const uint64_t powers_of_10_64[];
+ static const uint32_t zero_or_powers_of_10_32[];
+ static const uint64_t zero_or_powers_of_10_64[];
+ static const uint64_t pow10_significands[];
+ static const int16_t pow10_exponents[];
+ static const char digits[];
+ static const char hex_digits[];
+ static const char foreground_color[];
+ static const char background_color[];
+ static const char reset_color[5];
+ static const wchar_t wreset_color[5];
+ static const char signs[];
+ static const char left_padding_shifts[5];
+ static const char right_padding_shifts[5];
+};
+
+FMT_EXTERN template struct basic_data<void>;
+
+// This is a struct rather than an alias to avoid shadowing warnings in gcc.
+struct data : basic_data<> {};
#ifdef FMT_BUILTIN_CLZLL
// Returns the number of decimal digits in n. Leading zeros are not counted
// Based on http://graphics.stanford.edu/~seander/bithacks.html#IntegerLog10
// and the benchmark https://github.com/localvoid/cxx-benchmark-count-digits.
int t = (64 - FMT_BUILTIN_CLZLL(n | 1)) * 1233 >> 12;
- return t - (n < data::ZERO_OR_POWERS_OF_10_64[t]) + 1;
+ return t - (n < data::zero_or_powers_of_10_64[t]) + 1;
}
#else
// Fallback version of count_digits used when __builtin_clz is not available.
}
#endif
-template <typename Char>
-inline size_t count_code_points(basic_string_view<Char> s) {
- return s.size();
+#if FMT_USE_INT128
+inline int count_digits(uint128_t n) {
+ int count = 1;
+ for (;;) {
+ // Integer division is slow so do it for a group of four digits instead
+ // of for every digit. The idea comes from the talk by Alexandrescu
+ // "Three Optimization Tips for C++". See speed-test for a comparison.
+ if (n < 10) return count;
+ if (n < 100) return count + 1;
+ if (n < 1000) return count + 2;
+ if (n < 10000) return count + 3;
+ n /= 10000U;
+ count += 4;
+ }
}
+#endif
-// Counts the number of code points in a UTF-8 string.
-FMT_API size_t count_code_points(basic_string_view<char8_t> s);
-
-inline char8_t to_char8_t(char c) { return static_cast<char8_t>(c); }
-
-template <typename InputIt, typename OutChar>
-struct needs_conversion
- : std::integral_constant<
- bool, std::is_same<typename std::iterator_traits<InputIt>::value_type,
- char>::value &&
- std::is_same<OutChar, char8_t>::value> {};
-
-template <typename OutChar, typename InputIt, typename OutputIt,
- FMT_ENABLE_IF(!needs_conversion<InputIt, OutChar>::value)>
-OutputIt copy_str(InputIt begin, InputIt end, OutputIt it) {
- return std::copy(begin, end, it);
+// Counts the number of digits in n. BITS = log2(radix).
+template <unsigned BITS, typename UInt> inline int count_digits(UInt n) {
+ int num_digits = 0;
+ do {
+ ++num_digits;
+ } while ((n >>= BITS) != 0);
+ return num_digits;
}
-template <typename OutChar, typename InputIt, typename OutputIt,
- FMT_ENABLE_IF(needs_conversion<InputIt, OutChar>::value)>
-OutputIt copy_str(InputIt begin, InputIt end, OutputIt it) {
- return std::transform(begin, end, it, to_char8_t);
-}
+template <> int count_digits<4>(detail::fallback_uintptr n);
-#if FMT_HAS_CPP_ATTRIBUTE(always_inline)
-# define FMT_ALWAYS_INLINE __attribute__((always_inline))
+#if FMT_GCC_VERSION || FMT_CLANG_VERSION
+# define FMT_ALWAYS_INLINE inline __attribute__((always_inline))
#else
# define FMT_ALWAYS_INLINE
#endif
-template <typename Handler>
-inline char* lg(uint32_t n, Handler h) FMT_ALWAYS_INLINE;
-
-// Computes g = floor(log10(n)) and calls h.on<g>(n);
-template <typename Handler> inline char* lg(uint32_t n, Handler h) {
- return n < 100 ? n < 10 ? h.template on<0>(n) : h.template on<1>(n)
- : n < 1000000
- ? n < 10000 ? n < 1000 ? h.template on<2>(n)
- : h.template on<3>(n)
- : n < 100000 ? h.template on<4>(n)
- : h.template on<5>(n)
- : n < 100000000 ? n < 10000000 ? h.template on<6>(n)
- : h.template on<7>(n)
- : n < 1000000000 ? h.template on<8>(n)
- : h.template on<9>(n);
-}
-
-// An lg handler that formats a decimal number.
-// Usage: lg(n, decimal_formatter(buffer));
-class decimal_formatter {
- private:
- char* buffer_;
-
- void write_pair(unsigned N, uint32_t index) {
- std::memcpy(buffer_ + N, data::DIGITS + index * 2, 2);
- }
-
- public:
- explicit decimal_formatter(char* buf) : buffer_(buf) {}
-
- template <unsigned N> char* on(uint32_t u) {
- if (N == 0) {
- *buffer_ = static_cast<char>(u) + '0';
- } else if (N == 1) {
- write_pair(0, u);
- } else {
- // The idea of using 4.32 fixed-point numbers is based on
- // https://github.com/jeaiii/itoa
- unsigned n = N - 1;
- unsigned a = n / 5 * n * 53 / 16;
- uint64_t t =
- ((1ULL << (32 + a)) / data::ZERO_OR_POWERS_OF_10_32[n] + 1 - n / 9);
- t = ((t * u) >> a) + n / 5 * 4;
- write_pair(0, t >> 32);
- for (unsigned i = 2; i < N; i += 2) {
- t = 100ULL * static_cast<uint32_t>(t);
- write_pair(i, t >> 32);
- }
- if (N % 2 == 0) {
- buffer_[N] =
- static_cast<char>((10ULL * static_cast<uint32_t>(t)) >> 32) + '0';
- }
- }
- return buffer_ += N + 1;
- }
-};
-
-// An lg handler that formats a decimal number with a terminating null.
-class decimal_formatter_null : public decimal_formatter {
- public:
- explicit decimal_formatter_null(char* buf) : decimal_formatter(buf) {}
-
- template <unsigned N> char* on(uint32_t u) {
- char* buf = decimal_formatter::on<N>(u);
- *buf = '\0';
- return buf;
- }
-};
-
#ifdef FMT_BUILTIN_CLZ
// Optional version of count_digits for better performance on 32-bit platforms.
inline int count_digits(uint32_t n) {
int t = (32 - FMT_BUILTIN_CLZ(n | 1)) * 1233 >> 12;
- return t - (n < data::ZERO_OR_POWERS_OF_10_32[t]) + 1;
+ return t - (n < data::zero_or_powers_of_10_32[t]) + 1;
}
#endif
-// A functor that doesn't add a thousands separator.
-struct no_thousands_sep {
- typedef char char_type;
-
- template <typename Char> void operator()(Char*) {}
-
- enum { size = 0 };
-};
-
-// A functor that adds a thousands separator.
-template <typename Char> class add_thousands_sep {
- private:
- basic_string_view<Char> sep_;
-
- // Index of a decimal digit with the least significant digit having index 0.
- unsigned digit_index_;
-
- public:
- typedef Char char_type;
-
- explicit add_thousands_sep(basic_string_view<Char> sep)
- : sep_(sep), digit_index_(0) {}
-
- void operator()(Char*& buffer) {
- if (++digit_index_ % 3 != 0) return;
- buffer -= sep_.size();
- std::uninitialized_copy(sep_.data(), sep_.data() + sep_.size(),
- internal::make_checked(buffer, sep_.size()));
- }
-
- enum { size = 1 };
-};
+template <typename Char> FMT_API std::string grouping_impl(locale_ref loc);
+template <typename Char> inline std::string grouping(locale_ref loc) {
+ return grouping_impl<char>(loc);
+}
+template <> inline std::string grouping<wchar_t>(locale_ref loc) {
+ return grouping_impl<wchar_t>(loc);
+}
template <typename Char> FMT_API Char thousands_sep_impl(locale_ref loc);
-
template <typename Char> inline Char thousands_sep(locale_ref loc) {
return Char(thousands_sep_impl<char>(loc));
}
-
template <> inline wchar_t thousands_sep(locale_ref loc) {
return thousands_sep_impl<wchar_t>(loc);
}
+template <typename Char> FMT_API Char decimal_point_impl(locale_ref loc);
+template <typename Char> inline Char decimal_point(locale_ref loc) {
+ return Char(decimal_point_impl<char>(loc));
+}
+template <> inline wchar_t decimal_point(locale_ref loc) {
+ return decimal_point_impl<wchar_t>(loc);
+}
+
// Formats a decimal unsigned integer value writing into buffer.
-// thousands_sep is a functor that is called after writing each char to
-// add a thousands separator if necessary.
-template <typename UInt, typename Char, typename ThousandsSep>
+// add_thousands_sep is called after writing each char to add a thousands
+// separator if necessary.
+template <typename UInt, typename Char, typename F>
inline Char* format_decimal(Char* buffer, UInt value, int num_digits,
- ThousandsSep thousands_sep) {
+ F add_thousands_sep) {
FMT_ASSERT(num_digits >= 0, "invalid digit count");
buffer += num_digits;
Char* end = buffer;
// Integer division is slow so do it for a group of two digits instead
// of for every digit. The idea comes from the talk by Alexandrescu
// "Three Optimization Tips for C++". See speed-test for a comparison.
- unsigned index = static_cast<unsigned>((value % 100) * 2);
+ auto index = static_cast<unsigned>((value % 100) * 2);
value /= 100;
- *--buffer = static_cast<Char>(data::DIGITS[index + 1]);
- thousands_sep(buffer);
- *--buffer = static_cast<Char>(data::DIGITS[index]);
- thousands_sep(buffer);
+ *--buffer = static_cast<Char>(data::digits[index + 1]);
+ add_thousands_sep(buffer);
+ *--buffer = static_cast<Char>(data::digits[index]);
+ add_thousands_sep(buffer);
}
if (value < 10) {
*--buffer = static_cast<Char>('0' + value);
return end;
}
- unsigned index = static_cast<unsigned>(value * 2);
- *--buffer = static_cast<Char>(data::DIGITS[index + 1]);
- thousands_sep(buffer);
- *--buffer = static_cast<Char>(data::DIGITS[index]);
+ auto index = static_cast<unsigned>(value * 2);
+ *--buffer = static_cast<Char>(data::digits[index + 1]);
+ add_thousands_sep(buffer);
+ *--buffer = static_cast<Char>(data::digits[index]);
return end;
}
-template <typename OutChar, typename UInt, typename Iterator,
- typename ThousandsSep>
+template <typename Int> constexpr int digits10() FMT_NOEXCEPT {
+ return std::numeric_limits<Int>::digits10;
+}
+template <> constexpr int digits10<int128_t>() FMT_NOEXCEPT { return 38; }
+template <> constexpr int digits10<uint128_t>() FMT_NOEXCEPT { return 38; }
+
+template <typename Char, typename UInt, typename Iterator, typename F>
inline Iterator format_decimal(Iterator out, UInt value, int num_digits,
- ThousandsSep sep) {
+ F add_thousands_sep) {
FMT_ASSERT(num_digits >= 0, "invalid digit count");
- typedef typename ThousandsSep::char_type char_type;
// Buffer should be large enough to hold all digits (<= digits10 + 1).
- enum { max_size = std::numeric_limits<UInt>::digits10 + 1 };
- FMT_ASSERT(ThousandsSep::size <= 1, "invalid separator");
- char_type buffer[max_size + max_size / 3];
- auto end = format_decimal(buffer, value, num_digits, sep);
- return internal::copy_str<OutChar>(buffer, end, out);
+ enum { max_size = digits10<UInt>() + 1 };
+ Char buffer[2 * max_size];
+ auto end = format_decimal(buffer, value, num_digits, add_thousands_sep);
+ return detail::copy_str<Char>(buffer, end, out);
}
-template <typename OutChar, typename It, typename UInt>
+template <typename Char, typename It, typename UInt>
inline It format_decimal(It out, UInt value, int num_digits) {
- return format_decimal<OutChar>(out, value, num_digits, no_thousands_sep());
+ return format_decimal<Char>(out, value, num_digits, [](Char*) {});
}
template <unsigned BASE_BITS, typename Char, typename UInt>
buffer += num_digits;
Char* end = buffer;
do {
- const char* digits = upper ? "0123456789ABCDEF" : "0123456789abcdef";
+ const char* digits = upper ? "0123456789ABCDEF" : data::hex_digits;
unsigned digit = (value & ((1 << BASE_BITS) - 1));
*--buffer = static_cast<Char>(BASE_BITS < 4 ? static_cast<char>('0' + digit)
: digits[digit]);
return end;
}
+template <unsigned BASE_BITS, typename Char>
+Char* format_uint(Char* buffer, detail::fallback_uintptr n, int num_digits,
+ bool = false) {
+ auto char_digits = std::numeric_limits<unsigned char>::digits / 4;
+ int start = (num_digits + char_digits - 1) / char_digits - 1;
+ if (int start_digits = num_digits % char_digits) {
+ unsigned value = n.value[start--];
+ buffer = format_uint<BASE_BITS>(buffer, value, start_digits);
+ }
+ for (; start >= 0; --start) {
+ unsigned value = n.value[start];
+ buffer += char_digits;
+ auto p = buffer;
+ for (int i = 0; i < char_digits; ++i) {
+ unsigned digit = (value & ((1 << BASE_BITS) - 1));
+ *--p = static_cast<Char>(data::hex_digits[digit]);
+ value >>= BASE_BITS;
+ }
+ }
+ return buffer;
+}
+
template <unsigned BASE_BITS, typename Char, typename It, typename UInt>
inline It format_uint(It out, UInt value, int num_digits, bool upper = false) {
- // Buffer should be large enough to hold all digits (digits / BASE_BITS + 1)
- // and null.
- char buffer[std::numeric_limits<UInt>::digits / BASE_BITS + 2];
+ // Buffer should be large enough to hold all digits (digits / BASE_BITS + 1).
+ char buffer[num_bits<UInt>() / BASE_BITS + 1];
format_uint<BASE_BITS>(buffer, value, num_digits, upper);
- return internal::copy_str<Char>(buffer, buffer + num_digits, out);
+ return detail::copy_str<Char>(buffer, buffer + num_digits, out);
}
-#ifndef _WIN32
-# define FMT_USE_WINDOWS_H 0
-#elif !defined(FMT_USE_WINDOWS_H)
-# define FMT_USE_WINDOWS_H 1
-#endif
-
-// Define FMT_USE_WINDOWS_H to 0 to disable use of windows.h.
-// All the functionality that relies on it will be disabled too.
-#if FMT_USE_WINDOWS_H
// A converter from UTF-8 to UTF-16.
-// It is only provided for Windows since other systems support UTF-8 natively.
class utf8_to_utf16 {
private:
wmemory_buffer buffer_;
public:
FMT_API explicit utf8_to_utf16(string_view s);
- operator wstring_view() const { return wstring_view(&buffer_[0], size()); }
+ operator wstring_view() const { return {&buffer_[0], size()}; }
size_t size() const { return buffer_.size() - 1; }
const wchar_t* c_str() const { return &buffer_[0]; }
- std::wstring str() const { return std::wstring(&buffer_[0], size()); }
+ std::wstring str() const { return {&buffer_[0], size()}; }
};
-// A converter from UTF-16 to UTF-8.
-// It is only provided for Windows since other systems support UTF-8 natively.
-class utf16_to_utf8 {
+template <typename T = void> struct null {};
+
+// Workaround an array initialization issue in gcc 4.8.
+template <typename Char> struct fill_t {
private:
- memory_buffer buffer_;
+ enum { max_size = 4 };
+ Char data_[max_size];
+ unsigned char size_;
public:
- utf16_to_utf8() {}
- FMT_API explicit utf16_to_utf8(wstring_view s);
- 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()); }
+ FMT_CONSTEXPR void operator=(basic_string_view<Char> s) {
+ auto size = s.size();
+ if (size > max_size) {
+ FMT_THROW(format_error("invalid fill"));
+ return;
+ }
+ for (size_t i = 0; i < size; ++i) data_[i] = s[i];
+ size_ = static_cast<unsigned char>(size);
+ }
- // Performs conversion returning a system error code instead of
- // throwing exception on conversion error. This method may still throw
- // in case of memory allocation error.
- FMT_API int convert(wstring_view s);
-};
+ size_t size() const { return size_; }
+ const Char* data() const { return data_; }
-FMT_API void format_windows_error(fmt::internal::buffer& out, int error_code,
- fmt::string_view message) FMT_NOEXCEPT;
-#endif
+ FMT_CONSTEXPR Char& operator[](size_t index) { return data_[index]; }
+ FMT_CONSTEXPR const Char& operator[](size_t index) const {
+ return data_[index];
+ }
-template <typename T = void> struct null {};
-} // namespace internal
-
-enum alignment {
- ALIGN_DEFAULT,
- ALIGN_LEFT,
- ALIGN_RIGHT,
- ALIGN_CENTER,
- ALIGN_NUMERIC
+ static FMT_CONSTEXPR fill_t<Char> make() {
+ auto fill = fill_t<Char>();
+ fill[0] = Char(' ');
+ fill.size_ = 1;
+ return fill;
+ }
};
+} // namespace detail
-// Flags.
-enum { SIGN_FLAG = 1, PLUS_FLAG = 2, MINUS_FLAG = 4, HASH_FLAG = 8 };
-
-// An alignment specifier.
-struct align_spec {
- unsigned width_;
- // Fill is always wchar_t and cast to char if necessary to avoid having
- // two specialization of AlignSpec and its subclasses.
- wchar_t fill_;
- alignment align_;
-
- FMT_CONSTEXPR align_spec() : width_(0), fill_(' '), align_(ALIGN_DEFAULT) {}
- FMT_CONSTEXPR unsigned width() const { return width_; }
- FMT_CONSTEXPR wchar_t fill() const { return fill_; }
- FMT_CONSTEXPR alignment align() const { return align_; }
-};
+// We cannot use enum classes as bit fields because of a gcc bug
+// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=61414.
+namespace align {
+enum type { none, left, right, center, numeric };
+}
+using align_t = align::type;
+
+namespace sign {
+enum type { none, minus, plus, space };
+}
+using sign_t = sign::type;
-struct core_format_specs {
+// Format specifiers for built-in and string types.
+template <typename Char> struct basic_format_specs {
+ int width;
int precision;
- uint_least8_t flags;
char type;
+ align_t align : 4;
+ sign_t sign : 3;
+ bool alt : 1; // Alternate form ('#').
+ detail::fill_t<Char> fill;
- FMT_CONSTEXPR core_format_specs() : precision(-1), flags(0), type(0) {}
- FMT_CONSTEXPR bool has(unsigned f) const { return (flags & f) != 0; }
- FMT_CONSTEXPR bool has_precision() const { return precision != -1; }
-};
-
-// Format specifiers.
-template <typename Char>
-struct basic_format_specs : align_spec, core_format_specs {
- FMT_CONSTEXPR basic_format_specs() {}
+ constexpr basic_format_specs()
+ : width(0),
+ precision(-1),
+ type(0),
+ align(align::none),
+ sign(sign::none),
+ alt(false),
+ fill(detail::fill_t<Char>::make()) {}
};
-typedef basic_format_specs<char> format_specs;
-
-template <typename Char, typename ErrorHandler>
-FMT_CONSTEXPR unsigned basic_parse_context<Char, ErrorHandler>::next_arg_id() {
- if (next_arg_id_ >= 0) return internal::to_unsigned(next_arg_id_++);
- on_error("cannot switch from manual to automatic argument indexing");
- return 0;
-}
+using format_specs = basic_format_specs<char>;
-namespace internal {
+namespace detail {
-// Formats value using Grisu2 algorithm:
-// https://www.cs.tufts.edu/~nr/cs257/archive/florian-loitsch/printf.pdf
-template <typename Double, FMT_ENABLE_IF(sizeof(Double) == sizeof(uint64_t))>
-FMT_API bool grisu2_format(Double value, buffer& buf, int precision, bool fixed,
- int& exp);
-template <typename Double, FMT_ENABLE_IF(sizeof(Double) != sizeof(uint64_t))>
-inline bool grisu2_format(Double, buffer&, int, bool, int&) {
- return false;
-}
+// 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
+};
-struct gen_digits_params {
- int num_digits;
- bool fixed;
- bool upper;
- bool trailing_zeros;
+struct float_specs {
+ int precision;
+ float_format format : 8;
+ sign_t sign : 8;
+ bool upper : 1;
+ bool locale : 1;
+ bool binary32 : 1;
+ bool use_grisu : 1;
+ bool showpoint : 1;
};
// Writes the exponent exp in the form "[+-]d{2,3}" to buffer.
template <typename Char, typename It> It write_exponent(int exp, It it) {
- FMT_ASSERT(-1000 < exp && exp < 1000, "exponent out of range");
+ FMT_ASSERT(-10000 < exp && exp < 10000, "exponent out of range");
if (exp < 0) {
*it++ = static_cast<Char>('-');
exp = -exp;
*it++ = static_cast<Char>('+');
}
if (exp >= 100) {
- *it++ = static_cast<Char>(static_cast<char>('0' + exp / 100));
+ const char* top = data::digits + (exp / 100) * 2;
+ if (exp >= 1000) *it++ = static_cast<Char>(top[0]);
+ *it++ = static_cast<Char>(top[1]);
exp %= 100;
- const char* d = data::DIGITS + exp * 2;
- *it++ = static_cast<Char>(d[0]);
- *it++ = static_cast<Char>(d[1]);
- } else {
- const char* d = data::DIGITS + exp * 2;
- *it++ = static_cast<Char>(d[0]);
- *it++ = static_cast<Char>(d[1]);
}
+ const char* d = data::digits + exp * 2;
+ *it++ = static_cast<Char>(d[0]);
+ *it++ = static_cast<Char>(d[1]);
return it;
}
-// The number is given as v = digits * pow(10, exp).
-template <typename Char, typename It>
-It grisu2_prettify(const char* digits, int size, int exp, It it,
- gen_digits_params params) {
- // pow(10, full_exp - 1) <= v <= pow(10, full_exp).
- int full_exp = size + exp;
- if (!params.fixed) {
- // Insert a decimal point after the first digit and add an exponent.
- *it++ = static_cast<Char>(*digits);
- if (size > 1) *it++ = static_cast<Char>('.');
- exp += size - 1;
- it = copy_str<Char>(digits + 1, digits + size, it);
- if (size < params.num_digits)
- it = std::fill_n(it, params.num_digits - size, static_cast<Char>('0'));
- *it++ = static_cast<Char>(params.upper ? 'E' : 'e');
- return write_exponent<Char>(exp, it);
- }
- const int exp_threshold = 21;
- if (size <= full_exp && full_exp <= exp_threshold) {
- // 1234e7 -> 12340000000[.0+]
- it = copy_str<Char>(digits, digits + size, it);
- it = std::fill_n(it, full_exp - size, static_cast<Char>('0'));
- int num_zeros = (std::max)(params.num_digits - full_exp, 1);
- if (params.trailing_zeros) {
- *it++ = static_cast<Char>('.');
- it = std::fill_n(it, num_zeros, static_cast<Char>('0'));
+template <typename Char> class float_writer {
+ private:
+ // The number is given as v = digits_ * pow(10, exp_).
+ const char* digits_;
+ int num_digits_;
+ int exp_;
+ size_t size_;
+ float_specs specs_;
+ Char decimal_point_;
+
+ template <typename It> It prettify(It it) const {
+ // pow(10, full_exp - 1) <= v <= pow(10, full_exp).
+ int full_exp = num_digits_ + exp_;
+ if (specs_.format == float_format::exp) {
+ // Insert a decimal point after the first digit and add an exponent.
+ *it++ = static_cast<Char>(*digits_);
+ int num_zeros = specs_.precision - num_digits_;
+ if (num_digits_ > 1 || specs_.showpoint) *it++ = decimal_point_;
+ it = copy_str<Char>(digits_ + 1, digits_ + num_digits_, it);
+ if (num_zeros > 0 && specs_.showpoint)
+ it = std::fill_n(it, num_zeros, static_cast<Char>('0'));
+ *it++ = static_cast<Char>(specs_.upper ? 'E' : 'e');
+ return write_exponent<Char>(full_exp - 1, it);
}
- } else if (full_exp > 0) {
- // 1234e-2 -> 12.34[0+]
- it = copy_str<Char>(digits, digits + full_exp, it);
- *it++ = static_cast<Char>('.');
- if (!params.trailing_zeros) {
+ if (num_digits_ <= full_exp) {
+ // 1234e7 -> 12340000000[.0+]
+ it = copy_str<Char>(digits_, digits_ + num_digits_, it);
+ it = std::fill_n(it, full_exp - num_digits_, static_cast<Char>('0'));
+ if (specs_.showpoint || specs_.precision < 0) {
+ *it++ = decimal_point_;
+ int num_zeros = specs_.precision - full_exp;
+ if (num_zeros <= 0) {
+ if (specs_.format != float_format::fixed)
+ *it++ = static_cast<Char>('0');
+ return it;
+ }
+#ifdef FMT_FUZZ
+ if (num_zeros > 5000)
+ throw std::runtime_error("fuzz mode - avoiding excessive cpu use");
+#endif
+ it = std::fill_n(it, num_zeros, static_cast<Char>('0'));
+ }
+ } else if (full_exp > 0) {
+ // 1234e-2 -> 12.34[0+]
+ it = copy_str<Char>(digits_, digits_ + full_exp, it);
+ if (!specs_.showpoint) {
+ // Remove trailing zeros.
+ int num_digits = num_digits_;
+ while (num_digits > full_exp && digits_[num_digits - 1] == '0')
+ --num_digits;
+ if (num_digits != full_exp) *it++ = decimal_point_;
+ return copy_str<Char>(digits_ + full_exp, digits_ + num_digits, it);
+ }
+ *it++ = decimal_point_;
+ it = copy_str<Char>(digits_ + full_exp, digits_ + num_digits_, it);
+ if (specs_.precision > num_digits_) {
+ // Add trailing zeros.
+ int num_zeros = specs_.precision - num_digits_;
+ it = std::fill_n(it, num_zeros, static_cast<Char>('0'));
+ }
+ } else {
+ // 1234e-6 -> 0.001234
+ *it++ = static_cast<Char>('0');
+ int num_zeros = -full_exp;
+ int num_digits = num_digits_;
+ if (num_digits == 0 && specs_.precision >= 0 &&
+ specs_.precision < num_zeros) {
+ num_zeros = specs_.precision;
+ }
// Remove trailing zeros.
- while (size > full_exp && digits[size - 1] == '0') --size;
- return copy_str<Char>(digits + full_exp, digits + size, it);
+ if (!specs_.showpoint)
+ while (num_digits > 0 && digits_[num_digits - 1] == '0') --num_digits;
+ if (num_zeros != 0 || num_digits != 0 || specs_.showpoint) {
+ *it++ = decimal_point_;
+ it = std::fill_n(it, num_zeros, static_cast<Char>('0'));
+ it = copy_str<Char>(digits_, digits_ + num_digits, it);
+ }
}
- it = copy_str<Char>(digits + full_exp, digits + size, it);
- if (params.num_digits > size) {
- // Add trailing zeros.
- int num_zeros = params.num_digits - size;
- it = std::fill_n(it, num_zeros, static_cast<Char>('0'));
+ return it;
+ }
+
+ public:
+ float_writer(const char* digits, int num_digits, int exp, float_specs specs,
+ Char decimal_point)
+ : digits_(digits),
+ num_digits_(num_digits),
+ exp_(exp),
+ specs_(specs),
+ decimal_point_(decimal_point) {
+ int full_exp = num_digits + exp - 1;
+ int precision = specs.precision > 0 ? specs.precision : 16;
+ if (specs_.format == float_format::general &&
+ !(full_exp >= -4 && full_exp < precision)) {
+ specs_.format = float_format::exp;
}
- } else {
- // 1234e-6 -> 0.001234
- *it++ = static_cast<Char>('0');
- *it++ = static_cast<Char>('.');
- int num_zeros = -full_exp;
- if (params.num_digits >= 0 && params.num_digits < num_zeros)
- num_zeros = params.num_digits;
- it = std::fill_n(it, num_zeros, static_cast<Char>('0'));
- it = copy_str<Char>(digits, digits + size, it);
+ size_ = prettify(counting_iterator()).count();
+ size_ += specs.sign ? 1 : 0;
}
- return it;
-}
-template <typename Double>
-void sprintf_format(Double, internal::buffer&, core_format_specs);
+ size_t size() const { return size_; }
+
+ template <typename It> It operator()(It it) const {
+ if (specs_.sign) *it++ = static_cast<Char>(data::signs[specs_.sign]);
+ return prettify(it);
+ }
+};
+
+template <typename T>
+int format_float(T value, int precision, float_specs specs, buffer<char>& buf);
+
+// Formats a floating-point number with snprintf.
+template <typename T>
+int snprintf_float(T value, int precision, float_specs specs,
+ buffer<char>& buf);
+
+template <typename T> T promote_float(T value) { return value; }
+inline double promote_float(float value) { return static_cast<double>(value); }
template <typename Handler>
FMT_CONSTEXPR void handle_int_type_spec(char spec, Handler&& handler) {
handler.on_oct();
break;
case 'n':
+ case 'L':
handler.on_num();
break;
+ case 'c':
+ handler.on_chr();
+ break;
default:
handler.on_error();
}
}
-template <typename Handler>
-FMT_CONSTEXPR void handle_float_type_spec(char spec, Handler&& handler) {
- switch (spec) {
+template <typename ErrorHandler = error_handler, typename Char>
+FMT_CONSTEXPR float_specs parse_float_type_spec(
+ const basic_format_specs<Char>& specs, ErrorHandler&& eh = {}) {
+ auto result = float_specs();
+ result.showpoint = specs.alt;
+ switch (specs.type) {
case 0:
- case 'g':
+ result.format = float_format::general;
+ result.showpoint |= specs.precision > 0;
+ break;
case 'G':
- handler.on_general();
+ result.upper = true;
+ FMT_FALLTHROUGH;
+ case 'g':
+ result.format = float_format::general;
break;
- case 'e':
case 'E':
- handler.on_exp();
+ result.upper = true;
+ FMT_FALLTHROUGH;
+ case 'e':
+ result.format = float_format::exp;
+ result.showpoint |= specs.precision != 0;
break;
- case 'f':
case 'F':
- handler.on_fixed();
- break;
- case '%':
- handler.on_percent();
+ result.upper = true;
+ FMT_FALLTHROUGH;
+ case 'f':
+ result.format = float_format::fixed;
+ result.showpoint |= specs.precision != 0;
break;
- case 'a':
case 'A':
- handler.on_hex();
+ result.upper = true;
+ FMT_FALLTHROUGH;
+ case 'a':
+ result.format = float_format::hex;
+ break;
+ case 'n':
+ case 'L':
+ result.locale = true;
break;
default:
- handler.on_error();
+ eh.on_error("invalid type specifier");
break;
}
+ return result;
}
template <typename Char, typename Handler>
Handler&& handler) {
if (!specs) return handler.on_char();
if (specs->type && specs->type != 'c') return handler.on_int();
- if (specs->align() == ALIGN_NUMERIC || specs->flags != 0)
+ if (specs->align == align::numeric || specs->sign != sign::none || specs->alt)
handler.on_error("invalid format specifier for char");
handler.on_char();
}
FMT_CONSTEXPR void on_bin() {}
FMT_CONSTEXPR void on_oct() {}
FMT_CONSTEXPR void on_num() {}
-
- FMT_CONSTEXPR void on_error() {
- ErrorHandler::on_error("invalid type specifier");
- }
-};
-
-template <typename ErrorHandler>
-class float_type_checker : private ErrorHandler {
- public:
- FMT_CONSTEXPR explicit float_type_checker(ErrorHandler eh)
- : ErrorHandler(eh) {}
-
- FMT_CONSTEXPR void on_general() {}
- FMT_CONSTEXPR void on_exp() {}
- FMT_CONSTEXPR void on_fixed() {}
- FMT_CONSTEXPR void on_percent() {}
- FMT_CONSTEXPR void on_hex() {}
+ FMT_CONSTEXPR void on_chr() {}
FMT_CONSTEXPR void on_error() {
ErrorHandler::on_error("invalid type specifier");
FMT_CONSTEXPR void on_pointer() {}
};
-template <typename Context>
-void arg_map<Context>::init(const basic_format_args<Context>& args) {
- if (map_) return;
- map_ = new entry[args.max_size()];
- if (args.is_packed()) {
- for (unsigned i = 0; /*nothing*/; ++i) {
- internal::type arg_type = args.type(i);
- switch (arg_type) {
- case internal::none_type:
- return;
- case internal::named_arg_type:
- push_back(args.values_[i]);
- break;
- default:
- break; // Do nothing.
+template <typename OutputIt, typename Char>
+FMT_NOINLINE OutputIt fill(OutputIt it, size_t n, const fill_t<Char>& fill) {
+ auto fill_size = fill.size();
+ if (fill_size == 1) return std::fill_n(it, n, fill[0]);
+ for (size_t i = 0; i < n; ++i) it = std::copy_n(fill.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,
+ typename F>
+inline OutputIt write_padded(OutputIt out,
+ const basic_format_specs<Char>& specs, size_t size,
+ size_t width, const F& f) {
+ static_assert(align == align::left || align == align::right, "");
+ unsigned spec_width = to_unsigned(specs.width);
+ size_t padding = spec_width > width ? spec_width - width : 0;
+ auto* shifts = align == align::left ? data::left_padding_shifts
+ : data::right_padding_shifts;
+ size_t left_padding = padding >> shifts[specs.align];
+ auto it = reserve(out, size + padding * specs.fill.size());
+ it = fill(it, left_padding, specs.fill);
+ it = f(it);
+ it = fill(it, padding - left_padding, specs.fill);
+ return base_iterator(out, it);
+}
+
+template <align::type align = align::left, typename OutputIt, typename Char,
+ typename F>
+inline OutputIt write_padded(OutputIt out,
+ const basic_format_specs<Char>& specs, size_t size,
+ const F& f) {
+ return write_padded<align>(out, specs, size, size, f);
+}
+
+// Data for write_int that doesn't depend on output iterator type. It is used to
+// avoid template code bloat.
+template <typename Char> struct write_int_data {
+ size_t size;
+ size_t padding;
+
+ write_int_data(int num_digits, string_view prefix,
+ const basic_format_specs<Char>& specs)
+ : size(prefix.size() + to_unsigned(num_digits)), padding(0) {
+ if (specs.align == align::numeric) {
+ auto width = to_unsigned(specs.width);
+ if (width > size) {
+ padding = width - size;
+ size = width;
}
+ } else if (specs.precision > num_digits) {
+ size = prefix.size() + to_unsigned(specs.precision);
+ padding = to_unsigned(specs.precision - num_digits);
}
}
- for (unsigned i = 0;; ++i) {
- switch (args.args_[i].type_) {
- case internal::none_type:
- return;
- case internal::named_arg_type:
- push_back(args.args_[i].value_);
- break;
- default:
- break; // Do nothing.
- }
+};
+
+// Writes an integer in the format
+// <left-padding><prefix><numeric-padding><digits><right-padding>
+// where <digits> are written by f(it).
+template <typename OutputIt, typename Char, typename F>
+OutputIt write_int(OutputIt out, int num_digits, string_view prefix,
+ const basic_format_specs<Char>& specs, F f) {
+ auto data = write_int_data<Char>(num_digits, prefix, specs);
+ using iterator = remove_reference_t<decltype(reserve(out, 0))>;
+ return write_padded<align::right>(out, specs, data.size, [=](iterator it) {
+ if (prefix.size() != 0)
+ it = copy_str<Char>(prefix.begin(), prefix.end(), it);
+ it = std::fill_n(it, data.padding, static_cast<Char>('0'));
+ return f(it);
+ });
+}
+
+// The handle_int_type_spec handler that writes an integer.
+template <typename OutputIt, typename Char, typename UInt> struct int_writer {
+ OutputIt out;
+ locale_ref locale;
+ const basic_format_specs<Char>& specs;
+ UInt abs_value;
+ char prefix[4];
+ unsigned prefix_size;
+
+ using iterator =
+ remove_reference_t<decltype(reserve(std::declval<OutputIt&>(), 0))>;
+
+ string_view get_prefix() const { return string_view(prefix, prefix_size); }
+
+ template <typename Int>
+ int_writer(OutputIt output, locale_ref loc, Int value,
+ const basic_format_specs<Char>& s)
+ : out(output),
+ locale(loc),
+ specs(s),
+ abs_value(static_cast<UInt>(value)),
+ prefix_size(0) {
+ static_assert(std::is_same<uint32_or_64_or_128_t<Int>, UInt>::value, "");
+ if (is_negative(value)) {
+ prefix[0] = '-';
+ ++prefix_size;
+ abs_value = 0 - abs_value;
+ } else if (specs.sign != sign::none && specs.sign != sign::minus) {
+ prefix[0] = specs.sign == sign::plus ? '+' : ' ';
+ ++prefix_size;
+ }
}
+
+ void on_dec() {
+ auto num_digits = count_digits(abs_value);
+ out = write_int(out, num_digits, get_prefix(), specs,
+ [this, num_digits](iterator it) {
+ return format_decimal<Char>(it, abs_value, num_digits);
+ });
+ }
+
+ void on_hex() {
+ if (specs.alt) {
+ prefix[prefix_size++] = '0';
+ prefix[prefix_size++] = specs.type;
+ }
+ int num_digits = count_digits<4>(abs_value);
+ out = write_int(out, num_digits, get_prefix(), specs,
+ [this, num_digits](iterator it) {
+ return format_uint<4, Char>(it, abs_value, num_digits,
+ specs.type != 'x');
+ });
+ }
+
+ void on_bin() {
+ if (specs.alt) {
+ prefix[prefix_size++] = '0';
+ prefix[prefix_size++] = static_cast<char>(specs.type);
+ }
+ int num_digits = count_digits<1>(abs_value);
+ out = write_int(out, num_digits, get_prefix(), specs,
+ [this, num_digits](iterator it) {
+ return format_uint<1, Char>(it, abs_value, num_digits);
+ });
+ }
+
+ void on_oct() {
+ int num_digits = count_digits<3>(abs_value);
+ if (specs.alt && specs.precision <= num_digits && abs_value != 0) {
+ // Octal prefix '0' is counted as a digit, so only add it if precision
+ // is not greater than the number of digits.
+ prefix[prefix_size++] = '0';
+ }
+ out = write_int(out, num_digits, get_prefix(), specs,
+ [this, num_digits](iterator it) {
+ return format_uint<3, Char>(it, abs_value, num_digits);
+ });
+ }
+
+ enum { sep_size = 1 };
+
+ struct num_writer {
+ UInt abs_value;
+ int size;
+ const std::string& groups;
+ Char sep;
+
+ template <typename It> It operator()(It it) const {
+ basic_string_view<Char> s(&sep, sep_size);
+ // Index of a decimal digit with the least significant digit having
+ // index 0.
+ int digit_index = 0;
+ std::string::const_iterator group = groups.cbegin();
+ return format_decimal<Char>(
+ it, abs_value, size, [this, s, &group, &digit_index](Char*& buffer) {
+ if (*group <= 0 || ++digit_index % *group != 0 ||
+ *group == max_value<char>())
+ return;
+ if (group + 1 != groups.cend()) {
+ digit_index = 0;
+ ++group;
+ }
+ buffer -= s.size();
+ std::uninitialized_copy(s.data(), s.data() + s.size(),
+ make_checked(buffer, s.size()));
+ });
+ }
+ };
+
+ void on_num() {
+ std::string groups = grouping<Char>(locale);
+ if (groups.empty()) return on_dec();
+ auto sep = thousands_sep<Char>(locale);
+ if (!sep) return on_dec();
+ int num_digits = count_digits(abs_value);
+ int size = num_digits;
+ std::string::const_iterator group = groups.cbegin();
+ while (group != groups.cend() && num_digits > *group && *group > 0 &&
+ *group != max_value<char>()) {
+ size += sep_size;
+ num_digits -= *group;
+ ++group;
+ }
+ if (group == groups.cend())
+ size += sep_size * ((num_digits - 1) / groups.back());
+ out = write_int(out, size, get_prefix(), specs,
+ num_writer{abs_value, size, groups, sep});
+ }
+
+ void on_chr() { *out++ = static_cast<Char>(abs_value); }
+
+ FMT_NORETURN void on_error() {
+ FMT_THROW(format_error("invalid type specifier"));
+ }
+};
+
+template <typename Char, typename OutputIt>
+OutputIt write_bytes(OutputIt out, string_view bytes,
+ const basic_format_specs<Char>& specs) {
+ using iterator = remove_reference_t<decltype(reserve(out, 0))>;
+ return write_padded(out, specs, bytes.size(), [bytes](iterator it) {
+ const char* data = bytes.data();
+ return copy_str<Char>(data, data + bytes.size(), it);
+ });
+}
+
+template <typename Char, typename OutputIt>
+OutputIt write_nonfinite(OutputIt out, bool isinf,
+ const basic_format_specs<Char>& specs,
+ const float_specs& fspecs) {
+ auto str =
+ isinf ? (fspecs.upper ? "INF" : "inf") : (fspecs.upper ? "NAN" : "nan");
+ constexpr size_t str_size = 3;
+ auto sign = fspecs.sign;
+ auto size = str_size + (sign ? 1 : 0);
+ using iterator = remove_reference_t<decltype(reserve(out, 0))>;
+ return write_padded(out, specs, size, [=](iterator it) {
+ if (sign) *it++ = static_cast<Char>(data::signs[sign]);
+ return copy_str<Char>(str, str + str_size, it);
+ });
+}
+
+template <typename Char, typename OutputIt, typename T,
+ FMT_ENABLE_IF(std::is_floating_point<T>::value)>
+OutputIt write(OutputIt out, T value, basic_format_specs<Char> specs = {},
+ locale_ref loc = {}) {
+ if (const_check(!is_supported_floating_point(value))) return out;
+ float_specs fspecs = parse_float_type_spec(specs);
+ fspecs.sign = specs.sign;
+ if (std::signbit(value)) { // value < 0 is false for NaN so use signbit.
+ fspecs.sign = sign::minus;
+ value = -value;
+ } else if (fspecs.sign == sign::minus) {
+ fspecs.sign = sign::none;
+ }
+
+ if (!std::isfinite(value))
+ return write_nonfinite(out, std::isinf(value), specs, fspecs);
+
+ if (specs.align == align::numeric && fspecs.sign) {
+ auto it = reserve(out, 1);
+ *it++ = static_cast<Char>(data::signs[fspecs.sign]);
+ out = base_iterator(out, it);
+ fspecs.sign = sign::none;
+ if (specs.width != 0) --specs.width;
+ }
+
+ memory_buffer buffer;
+ if (fspecs.format == float_format::hex) {
+ if (fspecs.sign) buffer.push_back(data::signs[fspecs.sign]);
+ snprintf_float(promote_float(value), specs.precision, fspecs, buffer);
+ return write_bytes(out, {buffer.data(), buffer.size()}, specs);
+ }
+ int precision = specs.precision >= 0 || !specs.type ? specs.precision : 6;
+ if (fspecs.format == float_format::exp) {
+ if (precision == max_value<int>())
+ FMT_THROW(format_error("number is too big"));
+ else
+ ++precision;
+ }
+ if (const_check(std::is_same<T, float>())) fspecs.binary32 = true;
+ fspecs.use_grisu = use_grisu<T>();
+ int exp = format_float(promote_float(value), precision, fspecs, buffer);
+ fspecs.precision = precision;
+ Char point =
+ fspecs.locale ? decimal_point<Char>(loc) : static_cast<Char>('.');
+ float_writer<Char> w(buffer.data(), static_cast<int>(buffer.size()), exp,
+ fspecs, point);
+ return write_padded<align::right>(out, specs, w.size(), w);
+}
+
+template <typename StrChar, typename Char, typename OutputIt>
+OutputIt write(OutputIt out, basic_string_view<StrChar> s,
+ const basic_format_specs<Char>& specs = {}) {
+ 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));
+ auto width = specs.width != 0
+ ? count_code_points(basic_string_view<StrChar>(data, size))
+ : 0;
+ using iterator = remove_reference_t<decltype(reserve(out, 0))>;
+ return write_padded(out, specs, size, width, [=](iterator it) {
+ return copy_str<Char>(data, data + size, it);
+ });
+}
+
+template <typename Char, typename OutputIt, typename UIntPtr>
+OutputIt write_ptr(OutputIt out, UIntPtr value,
+ const basic_format_specs<Char>* specs) {
+ int num_digits = count_digits<4>(value);
+ auto size = to_unsigned(num_digits) + size_t(2);
+ using iterator = remove_reference_t<decltype(reserve(out, 0))>;
+ auto write = [=](iterator it) {
+ *it++ = static_cast<Char>('0');
+ *it++ = static_cast<Char>('x');
+ return format_uint<4, Char>(it, value, num_digits);
+ };
+ return specs ? write_padded<align::right>(out, *specs, size, write)
+ : base_iterator(out, write(reserve(out, size)));
}
-template <typename Range> class arg_formatter_base {
+template <typename T> struct is_integral : std::is_integral<T> {};
+template <> struct is_integral<int128_t> : std::true_type {};
+template <> struct is_integral<uint128_t> : std::true_type {};
+
+template <typename Range, typename ErrorHandler = detail::error_handler>
+class arg_formatter_base {
public:
- typedef typename Range::value_type char_type;
- typedef decltype(internal::declval<Range>().begin()) iterator;
- typedef basic_format_specs<char_type> format_specs;
+ using char_type = typename Range::value_type;
+ using iterator = typename Range::iterator;
+ using format_specs = basic_format_specs<char_type>;
private:
- typedef basic_writer<Range> writer_type;
- writer_type writer_;
+ iterator out_; // Output iterator.
+ locale_ref locale_;
format_specs* specs_;
+ // Attempts to reserve space for n extra characters in the output range.
+ // Returns a pointer to the reserved range or a reference to out_.
+ auto reserve(size_t n) -> decltype(detail::reserve(out_, n)) {
+ return detail::reserve(out_, n);
+ }
+
+ using reserve_iterator = remove_reference_t<decltype(
+ detail::reserve(std::declval<iterator&>(), 0))>;
+
struct char_writer {
char_type value;
size_t size() const { return 1; }
- size_t width() const { return 1; }
- template <typename It> void operator()(It&& it) const { *it++ = value; }
+ template <typename It> It operator()(It it) const {
+ *it++ = value;
+ return it;
+ }
};
void write_char(char_type value) {
if (specs_)
- writer_.write_padded(*specs_, char_writer{value});
+ out_ = write_padded(out_, *specs_, 1, char_writer{value});
else
- writer_.write(value);
+ write(value);
+ }
+
+ // Writes a decimal integer.
+ template <typename Int> void write_decimal(Int value) {
+ auto abs_value = static_cast<uint32_or_64_or_128_t<Int>>(value);
+ bool negative = is_negative(value);
+ // Don't do -abs_value since it trips unsigned-integer-overflow sanitizer.
+ if (negative) abs_value = ~abs_value + 1;
+ int num_digits = count_digits(abs_value);
+ auto&& it = reserve((negative ? 1 : 0) + static_cast<size_t>(num_digits));
+ if (negative) *it++ = static_cast<char_type>('-');
+ it = format_decimal<char_type>(it, abs_value, num_digits);
+ }
+
+ void write(int value) { write_decimal(value); }
+ void write(long value) { write_decimal(value); }
+ void write(long long value) { write_decimal(value); }
+
+ void write(unsigned value) { write_decimal(value); }
+ void write(unsigned long value) { write_decimal(value); }
+ void write(unsigned long long value) { write_decimal(value); }
+
+#if FMT_USE_INT128
+ void write(int128_t value) { write_decimal(value); }
+ void write(uint128_t value) { write_decimal(value); }
+#endif
+
+ template <typename T> void write_int(T value, const format_specs& spec) {
+ using uint_type = uint32_or_64_or_128_t<T>;
+ int_writer<iterator, char_type, uint_type> w(out_, locale_, value, spec);
+ handle_int_type_spec(spec.type, w);
+ out_ = w.out;
+ }
+
+ void write(char value) {
+ auto&& it = reserve(1);
+ *it++ = value;
+ }
+
+ template <typename Char, FMT_ENABLE_IF(std::is_same<Char, char_type>::value)>
+ void write(Char value) {
+ auto&& it = reserve(1);
+ *it++ = value;
+ }
+
+ void write(string_view value) {
+ auto&& it = reserve(value.size());
+ it = copy_str<char_type>(value.begin(), value.end(), it);
+ }
+ void write(wstring_view value) {
+ static_assert(std::is_same<char_type, wchar_t>::value, "");
+ auto&& it = reserve(value.size());
+ it = std::copy(value.begin(), value.end(), it);
+ }
+
+ template <typename Char>
+ void write(const Char* s, size_t size, const format_specs& specs) {
+ auto width = specs.width != 0
+ ? count_code_points(basic_string_view<Char>(s, size))
+ : 0;
+ out_ = write_padded(out_, specs, size, width, [=](reserve_iterator it) {
+ return copy_str<char_type>(s, s + size, it);
+ });
+ }
+
+ template <typename Char>
+ void write(basic_string_view<Char> s, const format_specs& specs = {}) {
+ out_ = detail::write(out_, s, specs);
}
void write_pointer(const void* p) {
- format_specs specs = specs_ ? *specs_ : format_specs();
- specs.flags = HASH_FLAG;
- specs.type = 'x';
- writer_.write_int(reinterpret_cast<uintptr_t>(p), specs);
+ out_ = write_ptr<char_type>(out_, detail::to_uintptr(p), specs_);
}
protected:
- writer_type& writer() { return writer_; }
- format_specs* spec() { return specs_; }
- iterator out() { return writer_.out(); }
+ iterator out() { return out_; }
+ format_specs* specs() { return specs_; }
void write(bool value) {
string_view sv(value ? "true" : "false");
- specs_ ? writer_.write(sv, *specs_) : writer_.write(sv);
+ specs_ ? write(sv, *specs_) : write(sv);
}
void write(const char_type* value) {
- if (!value) FMT_THROW(format_error("string pointer is null"));
- auto length = std::char_traits<char_type>::length(value);
- basic_string_view<char_type> sv(value, length);
- specs_ ? writer_.write(sv, *specs_) : writer_.write(sv);
+ if (!value) {
+ FMT_THROW(format_error("string pointer is null"));
+ } else {
+ auto length = std::char_traits<char_type>::length(value);
+ basic_string_view<char_type> sv(value, length);
+ specs_ ? write(sv, *specs_) : write(sv);
+ }
}
public:
arg_formatter_base(Range r, format_specs* s, locale_ref loc)
- : writer_(r, loc), specs_(s) {}
+ : out_(r.begin()), locale_(loc), specs_(s) {}
iterator operator()(monostate) {
FMT_ASSERT(false, "invalid argument type");
return out();
}
- template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value ||
- std::is_same<T, char_type>::value)>
+ template <typename T, FMT_ENABLE_IF(is_integral<T>::value)>
iterator operator()(T value) {
- // MSVC2013 fails to compile separate overloads for bool and char_type so
- // use std::is_same instead.
- if (std::is_same<T, bool>::value) {
- if (specs_ && specs_->type) return (*this)(value ? 1 : 0);
- write(value != 0);
- } else if (std::is_same<T, char_type>::value) {
- internal::handle_char_specs(
- specs_, char_spec_handler(*this, static_cast<char_type>(value)));
- } else {
- specs_ ? writer_.write_int(value, *specs_) : writer_.write(value);
- }
+ if (specs_)
+ write_int(value, *specs_);
+ else
+ write(value);
+ return out();
+ }
+
+ iterator operator()(char_type value) {
+ detail::handle_char_specs(
+ specs_, char_spec_handler(*this, static_cast<char_type>(value)));
+ return out();
+ }
+
+ iterator operator()(bool value) {
+ if (specs_ && specs_->type) return (*this)(value ? 1 : 0);
+ write(value != 0);
return out();
}
template <typename T, FMT_ENABLE_IF(std::is_floating_point<T>::value)>
iterator operator()(T value) {
- writer_.write_double(value, specs_ ? *specs_ : format_specs());
+ auto specs = specs_ ? *specs_ : format_specs();
+ if (const_check(is_supported_floating_point(value)))
+ out_ = detail::write(out_, value, specs, locale_);
+ else
+ FMT_ASSERT(false, "unsupported float argument type");
return out();
}
- struct char_spec_handler : internal::error_handler {
+ struct char_spec_handler : ErrorHandler {
arg_formatter_base& formatter;
char_type value;
void on_int() {
if (formatter.specs_)
- formatter.writer_.write_int(value, *formatter.specs_);
+ formatter.write_int(static_cast<int>(value), *formatter.specs_);
else
- formatter.writer_.write(value);
+ formatter.write(value);
}
void on_char() { formatter.write_char(value); }
};
- struct cstring_spec_handler : internal::error_handler {
+ struct cstring_spec_handler : detail::error_handler {
arg_formatter_base& formatter;
const char_type* value;
iterator operator()(const char_type* value) {
if (!specs_) return write(value), out();
- internal::handle_cstring_type_spec(specs_->type,
- cstring_spec_handler(*this, value));
+ detail::handle_cstring_type_spec(specs_->type,
+ cstring_spec_handler(*this, value));
return out();
}
iterator operator()(basic_string_view<char_type> value) {
if (specs_) {
- internal::check_string_type_spec(specs_->type, internal::error_handler());
- writer_.write(value, *specs_);
+ detail::check_string_type_spec(specs_->type, detail::error_handler());
+ write(value, *specs_);
} else {
- writer_.write(value);
+ write(value);
}
return out();
}
iterator operator()(const void* value) {
- if (specs_)
- check_pointer_type_spec(specs_->type, internal::error_handler());
+ if (specs_) check_pointer_type_spec(specs_->type, detail::error_handler());
write_pointer(value);
return out();
}
// 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, typename ErrorHandler>
-FMT_CONSTEXPR unsigned parse_nonnegative_int(const Char*& begin,
- const Char* end,
- ErrorHandler&& eh) {
- assert(begin != end && '0' <= *begin && *begin <= '9');
- if (*begin == '0') {
- ++begin;
- return 0;
- }
+FMT_CONSTEXPR int parse_nonnegative_int(const Char*& begin, const Char* end,
+ ErrorHandler&& eh) {
+ FMT_ASSERT(begin != end && '0' <= *begin && *begin <= '9', "");
unsigned value = 0;
// Convert to unsigned to prevent a warning.
- unsigned max_int = (std::numeric_limits<int>::max)();
+ constexpr unsigned max_int = max_value<int>();
unsigned big = max_int / 10;
do {
// Check for overflow.
++begin;
} while (begin != end && '0' <= *begin && *begin <= '9');
if (value > max_int) eh.on_error("number is too big");
- return value;
+ return static_cast<int>(value);
}
-template <typename Context> class custom_formatter : public function<bool> {
+template <typename Context> class custom_formatter {
private:
- typedef typename Context::char_type char_type;
+ using char_type = typename Context::char_type;
- basic_parse_context<char_type>& parse_ctx_;
+ basic_format_parse_context<char_type>& parse_ctx_;
Context& ctx_;
public:
- explicit custom_formatter(basic_parse_context<char_type>& parse_ctx,
+ explicit custom_formatter(basic_format_parse_context<char_type>& parse_ctx,
Context& ctx)
: parse_ctx_(parse_ctx), ctx_(ctx) {}
template <typename T> bool operator()(T) const { return false; }
};
-template <typename T> struct is_integer {
- enum {
- value = std::is_integral<T>::value && !std::is_same<T, bool>::value &&
- !std::is_same<T, char>::value && !std::is_same<T, wchar_t>::value
- };
-};
+template <typename T>
+using is_integer =
+ bool_constant<is_integral<T>::value && !std::is_same<T, bool>::value &&
+ !std::is_same<T, char>::value &&
+ !std::is_same<T, wchar_t>::value>;
-template <typename ErrorHandler>
-class width_checker : public function<unsigned long long> {
+template <typename ErrorHandler> class width_checker {
public:
explicit FMT_CONSTEXPR width_checker(ErrorHandler& eh) : handler_(eh) {}
ErrorHandler& handler_;
};
-template <typename ErrorHandler>
-class precision_checker : public function<unsigned long long> {
+template <typename ErrorHandler> class precision_checker {
public:
explicit FMT_CONSTEXPR precision_checker(ErrorHandler& eh) : handler_(eh) {}
FMT_CONSTEXPR specs_setter(const specs_setter& other)
: specs_(other.specs_) {}
- FMT_CONSTEXPR void on_align(alignment align) { specs_.align_ = align; }
- FMT_CONSTEXPR void on_fill(Char fill) { specs_.fill_ = fill; }
- FMT_CONSTEXPR void on_plus() { specs_.flags |= SIGN_FLAG | PLUS_FLAG; }
- FMT_CONSTEXPR void on_minus() { specs_.flags |= MINUS_FLAG; }
- FMT_CONSTEXPR void on_space() { specs_.flags |= SIGN_FLAG; }
- FMT_CONSTEXPR void on_hash() { specs_.flags |= HASH_FLAG; }
+ FMT_CONSTEXPR void on_align(align_t align) { specs_.align = align; }
+ FMT_CONSTEXPR void on_fill(basic_string_view<Char> fill) {
+ specs_.fill = fill;
+ }
+ FMT_CONSTEXPR void on_plus() { specs_.sign = sign::plus; }
+ FMT_CONSTEXPR void on_minus() { specs_.sign = sign::minus; }
+ FMT_CONSTEXPR void on_space() { specs_.sign = sign::space; }
+ FMT_CONSTEXPR void on_hash() { specs_.alt = true; }
FMT_CONSTEXPR void on_zero() {
- specs_.align_ = ALIGN_NUMERIC;
- specs_.fill_ = '0';
+ specs_.align = align::numeric;
+ specs_.fill[0] = Char('0');
}
- FMT_CONSTEXPR void on_width(unsigned width) { specs_.width_ = width; }
- FMT_CONSTEXPR void on_precision(unsigned precision) {
- specs_.precision = static_cast<int>(precision);
+ FMT_CONSTEXPR void on_width(int width) { specs_.width = width; }
+ FMT_CONSTEXPR void on_precision(int precision) {
+ specs_.precision = precision;
}
FMT_CONSTEXPR void end_precision() {}
template <typename ErrorHandler> class numeric_specs_checker {
public:
- FMT_CONSTEXPR numeric_specs_checker(ErrorHandler& eh, internal::type arg_type)
+ FMT_CONSTEXPR numeric_specs_checker(ErrorHandler& eh, detail::type arg_type)
: error_handler_(eh), arg_type_(arg_type) {}
FMT_CONSTEXPR void require_numeric_argument() {
- if (!is_arithmetic(arg_type_))
+ if (!is_arithmetic_type(arg_type_))
error_handler_.on_error("format specifier requires numeric argument");
}
FMT_CONSTEXPR void check_sign() {
require_numeric_argument();
- if (is_integral(arg_type_) && arg_type_ != int_type &&
- arg_type_ != long_long_type && arg_type_ != internal::char_type) {
+ if (is_integral_type(arg_type_) && arg_type_ != type::int_type &&
+ arg_type_ != type::long_long_type && arg_type_ != type::char_type) {
error_handler_.on_error("format specifier requires signed argument");
}
}
FMT_CONSTEXPR void check_precision() {
- if (is_integral(arg_type_) || arg_type_ == internal::pointer_type)
+ if (is_integral_type(arg_type_) || arg_type_ == type::pointer_type)
error_handler_.on_error("precision not allowed for this argument type");
}
private:
ErrorHandler& error_handler_;
- internal::type arg_type_;
+ detail::type arg_type_;
};
// A format specifier handler that checks if specifiers are consistent with the
// argument type.
template <typename Handler> class specs_checker : public Handler {
+ private:
+ numeric_specs_checker<Handler> checker_;
+
+ // Suppress an MSVC warning about using this in initializer list.
+ FMT_CONSTEXPR Handler& error_handler() { return *this; }
+
public:
- FMT_CONSTEXPR specs_checker(const Handler& handler, internal::type arg_type)
- : Handler(handler), checker_(*this, arg_type) {}
+ FMT_CONSTEXPR specs_checker(const Handler& handler, detail::type arg_type)
+ : Handler(handler), checker_(error_handler(), arg_type) {}
FMT_CONSTEXPR specs_checker(const specs_checker& other)
- : Handler(other), checker_(*this, other.arg_type_) {}
+ : Handler(other), checker_(error_handler(), other.arg_type_) {}
- FMT_CONSTEXPR void on_align(alignment align) {
- if (align == ALIGN_NUMERIC) checker_.require_numeric_argument();
+ FMT_CONSTEXPR void on_align(align_t align) {
+ if (align == align::numeric) checker_.require_numeric_argument();
Handler::on_align(align);
}
}
FMT_CONSTEXPR void end_precision() { checker_.check_precision(); }
-
- private:
- numeric_specs_checker<Handler> checker_;
};
-template <template <typename> class Handler, typename T, typename FormatArg,
+template <template <typename> class Handler, typename FormatArg,
typename ErrorHandler>
-FMT_CONSTEXPR void set_dynamic_spec(T& value, FormatArg arg, ErrorHandler eh) {
- unsigned long long big_value =
- visit_format_arg(Handler<ErrorHandler>(eh), arg);
- if (big_value > to_unsigned((std::numeric_limits<int>::max)()))
- eh.on_error("number is too big");
- value = static_cast<T>(big_value);
+FMT_CONSTEXPR int get_dynamic_spec(FormatArg arg, ErrorHandler eh) {
+ 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");
+ return static_cast<int>(value);
}
struct auto_id {};
+template <typename Context, typename ID>
+FMT_CONSTEXPR typename Context::format_arg get_arg(Context& ctx, ID id) {
+ auto arg = ctx.arg(id);
+ if (!arg) ctx.on_error("argument not found");
+ return arg;
+}
+
// The standard format specifier handler with checking.
template <typename ParseContext, typename Context>
class specs_handler : public specs_setter<typename Context::char_type> {
public:
- typedef typename Context::char_type char_type;
+ using char_type = typename Context::char_type;
FMT_CONSTEXPR specs_handler(basic_format_specs<char_type>& specs,
ParseContext& parse_ctx, Context& ctx)
context_(ctx) {}
template <typename Id> FMT_CONSTEXPR void on_dynamic_width(Id arg_id) {
- set_dynamic_spec<width_checker>(this->specs_.width_, get_arg(arg_id),
- context_.error_handler());
+ this->specs_.width = get_dynamic_spec<width_checker>(
+ get_arg(arg_id), context_.error_handler());
}
template <typename Id> FMT_CONSTEXPR void on_dynamic_precision(Id arg_id) {
- set_dynamic_spec<precision_checker>(this->specs_.precision, get_arg(arg_id),
- context_.error_handler());
+ this->specs_.precision = get_dynamic_spec<precision_checker>(
+ get_arg(arg_id), context_.error_handler());
}
void on_error(const char* message) { context_.on_error(message); }
private:
// This is only needed for compatibility with gcc 4.4.
- typedef typename Context::format_arg format_arg;
+ using format_arg = typename Context::format_arg;
FMT_CONSTEXPR format_arg get_arg(auto_id) {
- return internal::get_arg(context_, parse_context_.next_arg_id());
+ return detail::get_arg(context_, parse_context_.next_arg_id());
}
- FMT_CONSTEXPR format_arg get_arg(unsigned arg_id) {
+ FMT_CONSTEXPR format_arg get_arg(int arg_id) {
parse_context_.check_arg_id(arg_id);
- return internal::get_arg(context_, arg_id);
+ return detail::get_arg(context_, arg_id);
}
FMT_CONSTEXPR format_arg get_arg(basic_string_view<char_type> arg_id) {
parse_context_.check_arg_id(arg_id);
- return context_.arg(arg_id);
+ return detail::get_arg(context_, arg_id);
}
ParseContext& parse_context_;
Context& context_;
};
-struct string_view_metadata {
- FMT_CONSTEXPR string_view_metadata() : offset_(0u), size_(0u) {}
- template <typename Char>
- FMT_CONSTEXPR string_view_metadata(basic_string_view<Char> primary_string,
- basic_string_view<Char> view)
- : offset_(view.data() - primary_string.data()), size_(view.size()) {}
- FMT_CONSTEXPR string_view_metadata(std::size_t offset, std::size_t size)
- : offset_(offset), size_(size) {}
- template <typename S, FMT_ENABLE_IF(internal::is_string<S>::value)>
- FMT_CONSTEXPR basic_string_view<FMT_CHAR(S)> to_view(S&& str) const {
- const auto view = to_string_view(str);
- return basic_string_view<FMT_CHAR(S)>(view.data() + offset_, size_);
- }
-
- std::size_t offset_;
- std::size_t size_;
-};
+enum class arg_id_kind { none, index, name };
// An argument reference.
template <typename Char> struct arg_ref {
- enum Kind { NONE, INDEX, NAME };
- typedef Char char_type;
+ FMT_CONSTEXPR arg_ref() : kind(arg_id_kind::none), val() {}
- FMT_CONSTEXPR arg_ref() : kind(NONE), val() {}
- FMT_CONSTEXPR explicit arg_ref(unsigned index) : kind(INDEX), val(index) {}
- FMT_CONSTEXPR explicit arg_ref(string_view_metadata name)
- : kind(NAME), val(name) {}
+ 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 arg_ref& operator=(unsigned idx) {
- kind = INDEX;
+ FMT_CONSTEXPR arg_ref& operator=(int idx) {
+ kind = arg_id_kind::index;
val.index = idx;
return *this;
}
- Kind kind;
- FMT_UNRESTRICTED_UNION value {
- FMT_CONSTEXPR value() : index(0u) {}
- FMT_CONSTEXPR value(unsigned id) : index(id) {}
- FMT_CONSTEXPR value(string_view_metadata n) : name(n) {}
+ arg_id_kind kind;
+ union value {
+ FMT_CONSTEXPR value(int id = 0) : index{id} {}
+ FMT_CONSTEXPR value(basic_string_view<Char> n) : name(n) {}
- unsigned index;
- string_view_metadata name;
- }
- val;
+ int index;
+ basic_string_view<Char> name;
+ } val;
};
// Format specifiers with width and precision resolved at formatting rather
class dynamic_specs_handler
: public specs_setter<typename ParseContext::char_type> {
public:
- typedef typename ParseContext::char_type char_type;
+ using char_type = typename ParseContext::char_type;
FMT_CONSTEXPR dynamic_specs_handler(dynamic_format_specs<char_type>& specs,
ParseContext& ctx)
}
private:
- typedef arg_ref<char_type> arg_ref_type;
+ using arg_ref_type = arg_ref<char_type>;
- FMT_CONSTEXPR arg_ref_type make_arg_ref(unsigned arg_id) {
+ FMT_CONSTEXPR arg_ref_type make_arg_ref(int arg_id) {
context_.check_arg_id(arg_id);
return arg_ref_type(arg_id);
}
FMT_CONSTEXPR arg_ref_type make_arg_ref(basic_string_view<char_type> arg_id) {
context_.check_arg_id(arg_id);
- basic_string_view<char_type> format_str(context_.begin(),
- context_.end() - context_.begin());
- const auto id_metadata = string_view_metadata(format_str, arg_id);
- return arg_ref_type(id_metadata);
+ basic_string_view<char_type> format_str(
+ context_.begin(), to_unsigned(context_.end() - context_.begin()));
+ return arg_ref_type(arg_id);
}
dynamic_format_specs<char_type>& specs_;
template <typename Char, typename IDHandler>
FMT_CONSTEXPR const Char* parse_arg_id(const Char* begin, const Char* end,
IDHandler&& handler) {
- assert(begin != end);
+ FMT_ASSERT(begin != end, "");
Char c = *begin;
- if (c == '}' || c == ':') return handler(), begin;
+ if (c == '}' || c == ':') {
+ handler();
+ return begin;
+ }
if (c >= '0' && c <= '9') {
- unsigned index = parse_nonnegative_int(begin, end, handler);
+ int index = 0;
+ if (c != '0')
+ index = parse_nonnegative_int(begin, end, handler);
+ else
+ ++begin;
if (begin == end || (*begin != '}' && *begin != ':'))
- return handler.on_error("invalid format string"), begin;
- handler(index);
+ handler.on_error("invalid format string");
+ else
+ handler(index);
+ return begin;
+ }
+ if (!is_name_start(c)) {
+ handler.on_error("invalid format string");
return begin;
}
- if (!is_name_start(c))
- return handler.on_error("invalid format string"), begin;
auto it = begin;
do {
++it;
explicit FMT_CONSTEXPR width_adapter(SpecHandler& h) : handler(h) {}
FMT_CONSTEXPR void operator()() { handler.on_dynamic_width(auto_id()); }
- FMT_CONSTEXPR void operator()(unsigned id) { handler.on_dynamic_width(id); }
+ FMT_CONSTEXPR void operator()(int id) { handler.on_dynamic_width(id); }
FMT_CONSTEXPR void operator()(basic_string_view<Char> id) {
handler.on_dynamic_width(id);
}
explicit FMT_CONSTEXPR precision_adapter(SpecHandler& h) : handler(h) {}
FMT_CONSTEXPR void operator()() { handler.on_dynamic_precision(auto_id()); }
- FMT_CONSTEXPR void operator()(unsigned id) {
- handler.on_dynamic_precision(id);
- }
+ FMT_CONSTEXPR void operator()(int id) { handler.on_dynamic_precision(id); }
FMT_CONSTEXPR void operator()(basic_string_view<Char> id) {
handler.on_dynamic_precision(id);
}
SpecHandler& handler;
};
+template <typename Char>
+FMT_CONSTEXPR const Char* next_code_point(const Char* begin, const Char* end) {
+ if (const_check(sizeof(Char) != 1) || (*begin & 0x80) == 0) return begin + 1;
+ do {
+ ++begin;
+ } while (begin != end && (*begin & 0xc0) == 0x80);
+ return begin;
+}
+
// Parses fill and alignment.
template <typename Char, typename Handler>
FMT_CONSTEXPR const Char* parse_align(const Char* begin, const Char* end,
Handler&& handler) {
FMT_ASSERT(begin != end, "");
- alignment align = ALIGN_DEFAULT;
- int i = 0;
- if (begin + 1 != end) ++i;
- do {
- switch (static_cast<char>(begin[i])) {
+ auto align = align::none;
+ auto p = next_code_point(begin, end);
+ if (p == end) p = begin;
+ for (;;) {
+ switch (static_cast<char>(*p)) {
case '<':
- align = ALIGN_LEFT;
+ align = align::left;
break;
case '>':
- align = ALIGN_RIGHT;
+ align = align::right;
break;
+#if FMT_NUMERIC_ALIGN
case '=':
- align = ALIGN_NUMERIC;
+ align = align::numeric;
break;
+#endif
case '^':
- align = ALIGN_CENTER;
+ align = align::center;
break;
}
- if (align != ALIGN_DEFAULT) {
- if (i > 0) {
+ if (align != align::none) {
+ if (p != begin) {
auto c = *begin;
if (c == '{')
return handler.on_error("invalid fill character '{'"), begin;
- begin += 2;
- handler.on_fill(c);
+ handler.on_fill(basic_string_view<Char>(begin, to_unsigned(p - begin)));
+ begin = p + 1;
} else
++begin;
handler.on_align(align);
break;
+ } else if (p == begin) {
+ break;
}
- } while (i-- > 0);
+ p = begin;
+ }
return begin;
}
FMT_CONSTEXPR const Char* parse_precision(const Char* begin, const Char* end,
Handler&& handler) {
++begin;
- auto c = begin != end ? *begin : 0;
+ auto c = begin != end ? *begin : Char();
if ('0' <= c && c <= '9') {
handler.on_precision(parse_nonnegative_int(begin, end, handler));
} else if (c == '{') {
inline bool find<false, char>(const char* first, const char* last, char value,
const char*& out) {
out = static_cast<const char*>(
- std::memchr(first, value, internal::to_unsigned(last - first)));
- return out != FMT_NULL;
+ std::memchr(first, value, detail::to_unsigned(last - first)));
+ return out != nullptr;
}
template <typename Handler, typename Char> struct id_adapter {
FMT_CONSTEXPR void operator()() { handler.on_arg_id(); }
- FMT_CONSTEXPR void operator()(unsigned id) { handler.on_arg_id(id); }
+ FMT_CONSTEXPR void operator()(int id) { handler.on_arg_id(id); }
FMT_CONSTEXPR void operator()(basic_string_view<Char> id) {
handler.on_arg_id(id);
}
FMT_CONSTEXPR void operator()(const Char* begin, const Char* end) {
if (begin == end) return;
for (;;) {
- const Char* p = FMT_NULL;
+ const Char* p = nullptr;
if (!find<IS_CONSTEXPR>(begin, end, '}', p))
return handler_.on_text(begin, end);
++p;
// 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, end, '{', p))
+ if (*begin != '{' && !find<IS_CONSTEXPR>(begin + 1, end, '{', p))
return write(begin, end);
write(begin, p);
++p;
template <typename T, typename ParseContext>
FMT_CONSTEXPR const typename ParseContext::char_type* parse_format_specs(
ParseContext& ctx) {
- // GCC 7.2 requires initializer.
- formatter<T, typename ParseContext::char_type> f{};
+ using char_type = typename ParseContext::char_type;
+ using context = buffer_context<char_type>;
+ using mapped_type =
+ conditional_t<detail::mapped_type_constant<T, context>::value !=
+ type::custom_type,
+ decltype(arg_mapper<context>().map(std::declval<T>())), T>;
+ auto f = conditional_t<has_formatter<mapped_type, context>::value,
+ formatter<mapped_type, char_type>,
+ detail::fallback_formatter<T, char_type>>();
return f.parse(ctx);
}
-template <typename Char, typename ErrorHandler, typename... Args>
-class format_string_checker {
- public:
- explicit FMT_CONSTEXPR format_string_checker(
- basic_string_view<Char> format_str, ErrorHandler eh)
- : arg_id_((std::numeric_limits<unsigned>::max)()),
- context_(format_str, eh),
- parse_funcs_{&parse_format_specs<Args, parse_context_type>...} {}
-
- FMT_CONSTEXPR void on_text(const Char*, const Char*) {}
-
- FMT_CONSTEXPR void on_arg_id() {
- arg_id_ = context_.next_arg_id();
- check_arg_id();
- }
- FMT_CONSTEXPR void on_arg_id(unsigned id) {
- arg_id_ = id;
- context_.check_arg_id(id);
- check_arg_id();
- }
- FMT_CONSTEXPR void on_arg_id(basic_string_view<Char>) {
- on_error("compile-time checks don't support named arguments");
- }
-
- FMT_CONSTEXPR void on_replacement_field(const Char*) {}
-
- FMT_CONSTEXPR const Char* on_format_specs(const Char* begin, const Char*) {
- context_.advance_to(begin);
- return arg_id_ < NUM_ARGS ? parse_funcs_[arg_id_](context_) : begin;
- }
-
- FMT_CONSTEXPR void on_error(const char* message) {
- context_.on_error(message);
- }
-
- private:
- typedef basic_parse_context<Char, ErrorHandler> parse_context_type;
- enum { NUM_ARGS = sizeof...(Args) };
-
- FMT_CONSTEXPR void check_arg_id() {
- if (arg_id_ >= NUM_ARGS) context_.on_error("argument index out of range");
- }
-
- // Format specifier parsing function.
- typedef const Char* (*parse_func)(parse_context_type&);
-
- unsigned arg_id_;
- parse_context_type context_;
- parse_func parse_funcs_[NUM_ARGS > 0 ? NUM_ARGS : 1];
-};
-
-template <typename Char, typename ErrorHandler, typename... Args>
-FMT_CONSTEXPR bool do_check_format_string(basic_string_view<Char> s,
- ErrorHandler eh = ErrorHandler()) {
- format_string_checker<Char, ErrorHandler, Args...> checker(s, eh);
- parse_format_string<true>(s, checker);
- return true;
-}
-
-template <typename... Args, typename S,
- typename std::enable_if<is_compile_string<S>::value, int>::type>
-void check_format_string(S format_str) {
- typedef typename S::char_type char_t;
- FMT_CONSTEXPR_DECL bool invalid_format =
- internal::do_check_format_string<char_t, internal::error_handler,
- Args...>(to_string_view(format_str));
- (void)invalid_format;
-}
-
-// Specifies whether to format T using the standard formatter.
-// It is not possible to use get_type in formatter specialization directly
-// because of a bug in MSVC.
-template <typename Context, typename T>
-struct format_type
- : std::integral_constant<bool, get_type<Context, T>::value != custom_type> {
-};
-
-template <template <typename> class Handler, typename Spec, typename Context>
-void handle_dynamic_spec(Spec& value, arg_ref<typename Context::char_type> ref,
- Context& ctx,
- const typename Context::char_type* format_str) {
- typedef typename Context::char_type char_type;
- switch (ref.kind) {
- case arg_ref<char_type>::NONE:
- break;
- case arg_ref<char_type>::INDEX:
- internal::set_dynamic_spec<Handler>(value, ctx.arg(ref.val.index),
- ctx.error_handler());
- break;
- case arg_ref<char_type>::NAME: {
- const auto arg_id = ref.val.name.to_view(format_str);
- internal::set_dynamic_spec<Handler>(value, ctx.arg(arg_id),
- ctx.error_handler());
- } break;
- }
-}
-} // namespace internal
-
-/** The default argument formatter. */
-template <typename Range>
-class arg_formatter
- : public internal::function<
- typename internal::arg_formatter_base<Range>::iterator>,
- public internal::arg_formatter_base<Range> {
+// A parse context with extra argument id checks. It is only used at compile
+// time because adding checks at runtime would introduce substantial overhead
+// and would be redundant since argument ids are checked when arguments are
+// retrieved anyway.
+template <typename Char, typename ErrorHandler = error_handler>
+class compile_parse_context
+ : public basic_format_parse_context<Char, ErrorHandler> {
private:
- typedef typename Range::value_type char_type;
- typedef internal::arg_formatter_base<Range> base;
- typedef basic_format_context<typename base::iterator, char_type> context_type;
-
- context_type& ctx_;
- basic_parse_context<char_type>* parse_ctx_;
+ int num_args_;
+ using base = basic_format_parse_context<Char, ErrorHandler>;
public:
- typedef Range range;
- typedef typename base::iterator iterator;
- typedef typename base::format_specs format_specs;
+ explicit FMT_CONSTEXPR compile_parse_context(
+ basic_string_view<Char> format_str, int num_args = max_value<int>(),
+ ErrorHandler eh = {})
+ : base(format_str, eh), num_args_(num_args) {}
- /**
- \rst
- Constructs an argument formatter object.
- *ctx* is a reference to the formatting context,
- *spec* contains format specifier information for standard argument types.
- \endrst
- */
- explicit arg_formatter(context_type& ctx,
- basic_parse_context<char_type>* parse_ctx = FMT_NULL,
- format_specs* spec = FMT_NULL)
- : base(Range(ctx.out()), spec, ctx.locale()),
- ctx_(ctx),
- parse_ctx_(parse_ctx) {}
-
- FMT_DEPRECATED arg_formatter(context_type& ctx, format_specs& spec)
- : base(Range(ctx.out()), &spec), ctx_(ctx) {}
-
- using base::operator();
-
- /** Formats an argument of a user-defined type. */
- iterator operator()(typename basic_format_arg<context_type>::handle handle) {
- handle.format(*parse_ctx_, ctx_);
- return this->out();
+ FMT_CONSTEXPR int next_arg_id() {
+ int id = base::next_arg_id();
+ if (id >= num_args_) this->on_error("argument not found");
+ return id;
}
-};
-/**
- An error returned by an operating system or a language runtime,
- for example a file opening error.
-*/
-class system_error : public std::runtime_error {
- private:
- FMT_API void init(int err_code, string_view format_str, format_args args);
-
- protected:
- int error_code_;
-
- system_error() : std::runtime_error("") {}
-
- public:
- /**
- \rst
- Constructs a :class:`fmt::system_error` object with a description
- formatted with `fmt::format_system_error`. *message* and additional
- arguments passed into the constructor are formatted similarly to
- `fmt::format`.
-
- **Example**::
-
- // This throws a 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
- */
- template <typename... Args>
- system_error(int error_code, string_view message, const Args&... args)
- : std::runtime_error("") {
- init(error_code, message, make_format_args(args...));
+ FMT_CONSTEXPR void check_arg_id(int id) {
+ base::check_arg_id(id);
+ if (id >= num_args_) this->on_error("argument not found");
}
-
- int error_code() const { return error_code_; }
+ using base::check_arg_id;
};
-/**
- \rst
- Formats an error returned by an operating system or a language runtime,
- for example a file opening error, and writes it to *out* in the following
- form:
-
- .. 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``.
- If *error_code* is not a valid error code such as -1, the system message
- may look like "Unknown error -1" and is platform-dependent.
- \endrst
- */
-FMT_API void format_system_error(internal::buffer& out, int error_code,
- fmt::string_view message) FMT_NOEXCEPT;
-
-/**
- This template provides operations for formatting and writing data into a
- character range.
- */
-template <typename Range> class basic_writer {
- public:
- typedef typename Range::value_type char_type;
- typedef decltype(internal::declval<Range>().begin()) iterator;
- typedef basic_format_specs<char_type> format_specs;
-
- private:
- iterator out_; // Output iterator.
- internal::locale_ref locale_;
-
- // Attempts to reserve space for n extra characters in the output range.
- // Returns a pointer to the reserved range or a reference to out_.
- auto reserve(std::size_t n) -> decltype(internal::reserve(out_, n)) {
- return internal::reserve(out_, n);
- }
-
- // Writes a value in the format
- // <left-padding><value><right-padding>
- // where <value> is written by f(it).
- template <typename F> void write_padded(const align_spec& spec, F&& f) {
- unsigned width = spec.width(); // User-perceived width (in code points).
- size_t size = f.size(); // The number of code units.
- size_t num_code_points = width != 0 ? f.width() : size;
- if (width <= num_code_points) return f(reserve(size));
- auto&& it = reserve(width + (size - num_code_points));
- char_type fill = static_cast<char_type>(spec.fill());
- std::size_t padding = width - num_code_points;
- if (spec.align() == ALIGN_RIGHT) {
- it = std::fill_n(it, padding, fill);
- f(it);
- } else if (spec.align() == ALIGN_CENTER) {
- std::size_t left_padding = padding / 2;
- it = std::fill_n(it, left_padding, fill);
- f(it);
- it = std::fill_n(it, padding - left_padding, fill);
- } else {
- f(it);
- it = std::fill_n(it, padding, fill);
- }
- }
-
- template <typename F> struct padded_int_writer {
- size_t size_;
- string_view prefix;
- char_type fill;
- std::size_t padding;
- F f;
-
- size_t size() const { return size_; }
- size_t width() const { return size_; }
-
- template <typename It> void operator()(It&& it) const {
- if (prefix.size() != 0)
- it = internal::copy_str<char_type>(prefix.begin(), prefix.end(), it);
- it = std::fill_n(it, padding, fill);
- f(it);
- }
- };
-
- // Writes an integer in the format
- // <left-padding><prefix><numeric-padding><digits><right-padding>
- // where <digits> are written by f(it).
- template <typename Spec, typename F>
- void write_int(int num_digits, string_view prefix, const Spec& spec, F f) {
- std::size_t size = prefix.size() + internal::to_unsigned(num_digits);
- char_type fill = static_cast<char_type>(spec.fill());
- std::size_t padding = 0;
- if (spec.align() == ALIGN_NUMERIC) {
- if (spec.width() > size) {
- padding = spec.width() - size;
- size = spec.width();
- }
- } else if (spec.precision > num_digits) {
- size = prefix.size() + internal::to_unsigned(spec.precision);
- padding = internal::to_unsigned(spec.precision - num_digits);
- fill = static_cast<char_type>('0');
- }
- align_spec as = spec;
- if (spec.align() == ALIGN_DEFAULT) as.align_ = ALIGN_RIGHT;
- write_padded(as, padded_int_writer<F>{size, prefix, fill, padding, f});
- }
-
- // Writes a decimal integer.
- template <typename Int> void write_decimal(Int value) {
- typedef typename internal::int_traits<Int>::main_type main_type;
- main_type abs_value = static_cast<main_type>(value);
- bool is_negative = internal::is_negative(value);
- if (is_negative) abs_value = 0 - abs_value;
- int num_digits = internal::count_digits(abs_value);
- auto&& it =
- reserve((is_negative ? 1 : 0) + static_cast<size_t>(num_digits));
- if (is_negative) *it++ = static_cast<char_type>('-');
- it = internal::format_decimal<char_type>(it, abs_value, num_digits);
- }
-
- // The handle_int_type_spec handler that writes an integer.
- template <typename Int, typename Spec> struct int_writer {
- typedef typename internal::int_traits<Int>::main_type unsigned_type;
-
- basic_writer<Range>& writer;
- const Spec& spec;
- unsigned_type abs_value;
- char prefix[4];
- unsigned prefix_size;
-
- string_view get_prefix() const { return string_view(prefix, prefix_size); }
-
- // Counts the number of digits in abs_value. BITS = log2(radix).
- template <unsigned BITS> int count_digits() const {
- unsigned_type n = abs_value;
- int num_digits = 0;
- do {
- ++num_digits;
- } while ((n >>= BITS) != 0);
- return num_digits;
- }
-
- int_writer(basic_writer<Range>& w, Int value, const Spec& s)
- : writer(w),
- spec(s),
- abs_value(static_cast<unsigned_type>(value)),
- prefix_size(0) {
- if (internal::is_negative(value)) {
- prefix[0] = '-';
- ++prefix_size;
- abs_value = 0 - abs_value;
- } else if (spec.has(SIGN_FLAG)) {
- prefix[0] = spec.has(PLUS_FLAG) ? '+' : ' ';
- ++prefix_size;
- }
- }
-
- struct dec_writer {
- unsigned_type abs_value;
- int num_digits;
-
- template <typename It> void operator()(It&& it) const {
- it = internal::format_decimal<char_type>(it, abs_value, num_digits);
- }
- };
-
- void on_dec() {
- int num_digits = internal::count_digits(abs_value);
- writer.write_int(num_digits, get_prefix(), spec,
- dec_writer{abs_value, num_digits});
- }
-
- struct hex_writer {
- int_writer& self;
- int num_digits;
-
- template <typename It> void operator()(It&& it) const {
- it = internal::format_uint<4, char_type>(it, self.abs_value, num_digits,
- self.spec.type != 'x');
- }
- };
-
- void on_hex() {
- if (spec.has(HASH_FLAG)) {
- prefix[prefix_size++] = '0';
- prefix[prefix_size++] = static_cast<char>(spec.type);
- }
- int num_digits = count_digits<4>();
- writer.write_int(num_digits, get_prefix(), spec,
- hex_writer{*this, num_digits});
- }
-
- template <int BITS> struct bin_writer {
- unsigned_type abs_value;
- int num_digits;
-
- template <typename It> void operator()(It&& it) const {
- it = internal::format_uint<BITS, char_type>(it, abs_value, num_digits);
- }
- };
-
- void on_bin() {
- if (spec.has(HASH_FLAG)) {
- prefix[prefix_size++] = '0';
- prefix[prefix_size++] = static_cast<char>(spec.type);
- }
- int num_digits = count_digits<1>();
- writer.write_int(num_digits, get_prefix(), spec,
- bin_writer<1>{abs_value, num_digits});
- }
-
- void on_oct() {
- int num_digits = count_digits<3>();
- if (spec.has(HASH_FLAG) && spec.precision <= num_digits) {
- // Octal prefix '0' is counted as a digit, so only add it if precision
- // is not greater than the number of digits.
- prefix[prefix_size++] = '0';
- }
- writer.write_int(num_digits, get_prefix(), spec,
- bin_writer<3>{abs_value, num_digits});
- }
-
- enum { SEP_SIZE = 1 };
-
- struct num_writer {
- unsigned_type abs_value;
- int size;
- char_type sep;
-
- template <typename It> void operator()(It&& it) const {
- basic_string_view<char_type> s(&sep, SEP_SIZE);
- it = internal::format_decimal<char_type>(
- it, abs_value, size, internal::add_thousands_sep<char_type>(s));
- }
- };
-
- void on_num() {
- int num_digits = internal::count_digits(abs_value);
- char_type sep = internal::thousands_sep<char_type>(writer.locale_);
- int size = num_digits + SEP_SIZE * ((num_digits - 1) / 3);
- writer.write_int(size, get_prefix(), spec,
- num_writer{abs_value, size, sep});
- }
-
- void on_error() { FMT_THROW(format_error("invalid type specifier")); }
- };
-
- // Writes a formatted integer.
- template <typename T, typename Spec>
- void write_int(T value, const Spec& spec) {
- internal::handle_int_type_spec(spec.type,
- int_writer<T, Spec>(*this, value, spec));
- }
-
- enum { INF_SIZE = 3 }; // This is an enum to workaround a bug in MSVC.
-
- struct inf_or_nan_writer {
- char sign;
- bool as_percentage;
- const char* str;
-
- size_t size() const {
- return static_cast<std::size_t>(INF_SIZE + (sign ? 1 : 0) +
- (as_percentage ? 1 : 0));
- }
- size_t width() const { return size(); }
-
- template <typename It> void operator()(It&& it) const {
- if (sign) *it++ = static_cast<char_type>(sign);
- it = internal::copy_str<char_type>(
- str, str + static_cast<std::size_t>(INF_SIZE), it);
- if (as_percentage) *it++ = static_cast<char_type>('%');
- }
- };
-
- struct double_writer {
- char sign;
- internal::buffer& buffer;
-
- size_t size() const { return buffer.size() + (sign ? 1 : 0); }
- size_t width() const { return size(); }
-
- template <typename It> void operator()(It&& it) {
- if (sign) *it++ = static_cast<char_type>(sign);
- it = internal::copy_str<char_type>(buffer.begin(), buffer.end(), it);
- }
- };
-
- class grisu_writer {
- private:
- internal::buffer& digits_;
- size_t size_;
- char sign_;
- int exp_;
- internal::gen_digits_params params_;
-
- public:
- grisu_writer(char sign, internal::buffer& digits, int exp,
- const internal::gen_digits_params& params)
- : digits_(digits), sign_(sign), exp_(exp), params_(params) {
- int num_digits = static_cast<int>(digits.size());
- int full_exp = num_digits + exp - 1;
- int precision = params.num_digits > 0 ? params.num_digits : 11;
- params_.fixed |= full_exp >= -4 && full_exp < precision;
- auto it = internal::grisu2_prettify<char>(
- digits.data(), num_digits, exp, internal::counting_iterator<char>(),
- params_);
- size_ = it.count();
- }
-
- size_t size() const { return size_ + (sign_ ? 1 : 0); }
- size_t width() const { return size(); }
-
- template <typename It> void operator()(It&& it) {
- if (sign_) *it++ = static_cast<char_type>(sign_);
- int num_digits = static_cast<int>(digits_.size());
- it = internal::grisu2_prettify<char_type>(digits_.data(), num_digits,
- exp_, it, params_);
- }
- };
-
- // Formats a floating-point number (double or long double).
- template <typename T> void write_double(T value, const format_specs& spec);
-
- template <typename Char> struct str_writer {
- const Char* s;
- size_t size_;
-
- size_t size() const { return size_; }
- size_t width() const {
- return internal::count_code_points(basic_string_view<Char>(s, size_));
- }
-
- template <typename It> void operator()(It&& it) const {
- it = internal::copy_str<char_type>(s, s + size_, it);
- }
- };
-
- template <typename Char> friend class internal::arg_formatter_base;
-
+template <typename Char, typename ErrorHandler, typename... Args>
+class format_string_checker {
public:
- /** Constructs a ``basic_writer`` object. */
- explicit basic_writer(Range out,
- internal::locale_ref loc = internal::locale_ref())
- : out_(out.begin()), locale_(loc) {}
-
- iterator out() const { return out_; }
-
- void write(int value) { write_decimal(value); }
- void write(long value) { write_decimal(value); }
- void write(long long value) { write_decimal(value); }
-
- void write(unsigned value) { write_decimal(value); }
- void write(unsigned long value) { write_decimal(value); }
- void write(unsigned long long value) { write_decimal(value); }
-
- /**
- \rst
- Formats *value* and writes it to the buffer.
- \endrst
- */
- template <typename T, typename FormatSpec, typename... FormatSpecs,
- FMT_ENABLE_IF(std::is_integral<T>::value)>
- void write(T value, FormatSpec spec, FormatSpecs... specs) {
- format_specs s(spec, specs...);
- s.align_ = ALIGN_RIGHT;
- write_int(value, s);
- }
-
- void write(double value) { write_double(value, format_specs()); }
-
- /**
- \rst
- Formats *value* using the general format for floating-point numbers
- (``'g'``) and writes it to the buffer.
- \endrst
- */
- void write(long double value) { write_double(value, format_specs()); }
+ explicit FMT_CONSTEXPR format_string_checker(
+ basic_string_view<Char> format_str, ErrorHandler eh)
+ : arg_id_(-1),
+ context_(format_str, num_args, eh),
+ parse_funcs_{&parse_format_specs<Args, parse_context_type>...} {}
- /** Writes a character to the buffer. */
- void write(char value) {
- auto&& it = reserve(1);
- *it++ = value;
- }
- void write(wchar_t value) {
- static_assert(std::is_same<char_type, wchar_t>::value, "");
- auto&& it = reserve(1);
- *it++ = value;
- }
+ FMT_CONSTEXPR void on_text(const Char*, const Char*) {}
- /**
- \rst
- Writes *value* to the buffer.
- \endrst
- */
- void write(string_view value) {
- auto&& it = reserve(value.size());
- it = internal::copy_str<char_type>(value.begin(), value.end(), it);
- }
- void write(wstring_view value) {
- static_assert(std::is_same<char_type, wchar_t>::value, "");
- auto&& it = reserve(value.size());
- it = std::copy(value.begin(), value.end(), it);
+ FMT_CONSTEXPR void on_arg_id() { arg_id_ = context_.next_arg_id(); }
+ FMT_CONSTEXPR void on_arg_id(int id) {
+ arg_id_ = id;
+ context_.check_arg_id(id);
+ }
+ FMT_CONSTEXPR void on_arg_id(basic_string_view<Char>) {
+ on_error("compile-time checks don't support named arguments");
}
- // Writes a formatted string.
- template <typename Char>
- void write(const Char* s, std::size_t size, const align_spec& spec) {
- write_padded(spec, str_writer<Char>{s, size});
+ FMT_CONSTEXPR void on_replacement_field(const Char*) {}
+
+ FMT_CONSTEXPR const Char* on_format_specs(const Char* begin, const Char*) {
+ advance_to(context_, begin);
+ return arg_id_ < num_args ? parse_funcs_[arg_id_](context_) : begin;
}
- template <typename Char>
- void write(basic_string_view<Char> s,
- const format_specs& spec = format_specs()) {
- const Char* data = s.data();
- std::size_t size = s.size();
- if (spec.precision >= 0 && internal::to_unsigned(spec.precision) < size)
- size = internal::to_unsigned(spec.precision);
- write(data, size, spec);
- }
-
- template <typename T, FMT_ENABLE_IF(std::is_same<T, void>::value)>
- void write(const T* p) {
- format_specs specs;
- specs.flags = HASH_FLAG;
- specs.type = 'x';
- write_int(reinterpret_cast<uintptr_t>(p), specs);
+ FMT_CONSTEXPR void on_error(const char* message) {
+ context_.on_error(message);
}
+
+ private:
+ using parse_context_type = compile_parse_context<Char, ErrorHandler>;
+ enum { num_args = sizeof...(Args) };
+
+ // Format specifier parsing function.
+ using parse_func = const Char* (*)(parse_context_type&);
+
+ int arg_id_;
+ parse_context_type context_;
+ parse_func parse_funcs_[num_args > 0 ? num_args : 1];
};
-struct float_spec_handler {
- char type;
- bool upper;
- bool fixed;
- bool as_percentage;
+// Converts string literals to basic_string_view.
+template <typename Char, size_t N>
+FMT_CONSTEXPR basic_string_view<Char> compile_string_to_view(
+ const Char (&s)[N]) {
+ // Remove trailing null character if needed. Won't be present if this is used
+ // with raw character array (i.e. not defined as a string).
+ return {s,
+ N - ((std::char_traits<Char>::to_int_type(s[N - 1]) == 0) ? 1 : 0)};
+}
- explicit float_spec_handler(char t)
- : type(t), upper(false), fixed(false), as_percentage(false) {}
+// Converts string_view to basic_string_view.
+template <typename Char>
+FMT_CONSTEXPR basic_string_view<Char> compile_string_to_view(
+ const std_string_view<Char>& s) {
+ return {s.data(), s.size()};
+}
+
+#define FMT_STRING_IMPL(s, ...) \
+ [] { \
+ /* Use a macro-like name to avoid shadowing warnings. */ \
+ struct FMT_COMPILE_STRING : fmt::compile_string { \
+ using char_type = fmt::remove_cvref_t<decltype(s[0])>; \
+ FMT_MAYBE_UNUSED __VA_ARGS__ FMT_CONSTEXPR \
+ operator fmt::basic_string_view<char_type>() const { \
+ return fmt::detail::compile_string_to_view<char_type>(s); \
+ } \
+ }; \
+ return FMT_COMPILE_STRING(); \
+ }()
- void on_general() {
- if (type == 'G') upper = true;
- }
+/**
+ \rst
+ Constructs a compile-time format string from a string literal *s*.
- void on_exp() {
- if (type == 'E') upper = true;
- }
+ **Example**::
- void on_fixed() {
- fixed = true;
- if (type == 'F') upper = true;
- }
+ // A compile-time error because 'd' is an invalid specifier for strings.
+ std::string s = format(FMT_STRING("{:d}"), "foo");
+ \endrst
+ */
+#define FMT_STRING(s) FMT_STRING_IMPL(s, )
- void on_percent() {
- fixed = true;
- as_percentage = true;
- }
+template <typename... Args, typename S,
+ enable_if_t<(is_compile_string<S>::value), int>>
+void check_format_string(S format_str) {
+ FMT_CONSTEXPR_DECL auto s = to_string_view(format_str);
+ using checker = format_string_checker<typename S::char_type, error_handler,
+ remove_cvref_t<Args>...>;
+ FMT_CONSTEXPR_DECL bool invalid_format =
+ (parse_format_string<true>(s, checker(s, {})), true);
+ (void)invalid_format;
+}
- void on_hex() {
- if (type == 'A') upper = true;
+template <template <typename> class Handler, typename Context>
+void handle_dynamic_spec(int& value, arg_ref<typename Context::char_type> ref,
+ Context& ctx) {
+ switch (ref.kind) {
+ case arg_id_kind::none:
+ break;
+ case arg_id_kind::index:
+ value = detail::get_dynamic_spec<Handler>(ctx.arg(ref.val.index),
+ ctx.error_handler());
+ break;
+ case arg_id_kind::name:
+ value = detail::get_dynamic_spec<Handler>(ctx.arg(ref.val.name),
+ ctx.error_handler());
+ break;
}
+}
- void on_error() { FMT_THROW(format_error("invalid type specifier")); }
-};
+using format_func = void (*)(detail::buffer<char>&, int, string_view);
+
+FMT_API void format_error_code(buffer<char>& out, int error_code,
+ string_view message) FMT_NOEXCEPT;
+FMT_API void report_error(format_func func, int error_code,
+ string_view message) FMT_NOEXCEPT;
+} // namespace detail
+
+/** The default argument formatter. */
template <typename Range>
-template <typename T>
-void basic_writer<Range>::write_double(T value, const format_specs& spec) {
- // Check type.
- float_spec_handler handler(static_cast<char>(spec.type));
- internal::handle_float_type_spec(handler.type, handler);
-
- char sign = 0;
- // Use signbit instead of value < 0 since the latter is always false for NaN.
- if (std::signbit(value)) {
- sign = '-';
- value = -value;
- } else if (spec.has(SIGN_FLAG)) {
- sign = spec.has(PLUS_FLAG) ? '+' : ' ';
- }
+class arg_formatter : public detail::arg_formatter_base<Range> {
+ private:
+ using char_type = typename Range::value_type;
+ using base = detail::arg_formatter_base<Range>;
+ using context_type = basic_format_context<typename base::iterator, char_type>;
- if (!std::isfinite(value)) {
- // Format infinity and NaN ourselves because sprintf's output is not
- // consistent across platforms.
- const char* str = std::isinf(value) ? (handler.upper ? "INF" : "inf")
- : (handler.upper ? "NAN" : "nan");
- return write_padded(spec,
- inf_or_nan_writer{sign, handler.as_percentage, str});
- }
+ context_type& ctx_;
+ basic_format_parse_context<char_type>* parse_ctx_;
- if (handler.as_percentage) value *= 100;
+ public:
+ using range = Range;
+ using iterator = typename base::iterator;
+ using format_specs = typename base::format_specs;
- memory_buffer buffer;
- int exp = 0;
- int precision = spec.has_precision() || !spec.type ? spec.precision : 6;
- bool use_grisu = fmt::internal::use_grisu<T>() &&
- (spec.type != 'a' && spec.type != 'A' && spec.type != 'e' &&
- spec.type != 'E') &&
- internal::grisu2_format(static_cast<double>(value), buffer,
- precision, handler.fixed, exp);
- if (!use_grisu) internal::sprintf_format(value, buffer, spec);
-
- if (handler.as_percentage) {
- buffer.push_back('%');
- --exp; // Adjust decimal place position.
- }
- align_spec as = spec;
- if (spec.align() == ALIGN_NUMERIC) {
- if (sign) {
- auto&& it = reserve(1);
- *it++ = static_cast<char_type>(sign);
- sign = 0;
- if (as.width_) --as.width_;
- }
- as.align_ = ALIGN_RIGHT;
- } else if (spec.align() == ALIGN_DEFAULT) {
- as.align_ = ALIGN_RIGHT;
- }
- if (use_grisu) {
- auto params = internal::gen_digits_params();
- params.fixed = handler.fixed;
- params.num_digits = precision;
- params.trailing_zeros = (precision != 0 && (handler.fixed || !spec.type)) ||
- spec.has(HASH_FLAG);
- write_padded(as, grisu_writer{sign, buffer, exp, params});
- } else {
- write_padded(as, double_writer{sign, buffer});
- }
-}
+ /**
+ \rst
+ Constructs an argument formatter object.
+ *ctx* is a reference to the formatting context,
+ *specs* contains format specifier information for standard argument types.
+ \endrst
+ */
+ explicit arg_formatter(
+ context_type& ctx,
+ basic_format_parse_context<char_type>* parse_ctx = nullptr,
+ format_specs* specs = nullptr)
+ : base(Range(ctx.out()), specs, ctx.locale()),
+ ctx_(ctx),
+ parse_ctx_(parse_ctx) {}
-// Reports a system error without throwing an exception.
-// Can be used to report errors from destructors.
-FMT_API void report_system_error(int error_code,
- string_view message) FMT_NOEXCEPT;
+ using base::operator();
-#if FMT_USE_WINDOWS_H
+ /** Formats an argument of a user-defined type. */
+ iterator operator()(typename basic_format_arg<context_type>::handle handle) {
+ handle.format(*parse_ctx_, ctx_);
+ return ctx_.out();
+ }
+};
-/** A Windows error. */
-class windows_error : public system_error {
+/**
+ An error returned by an operating system or a language runtime,
+ for example a file opening error.
+*/
+FMT_CLASS_API
+class FMT_API system_error : public std::runtime_error {
private:
- FMT_API void init(int error_code, string_view format_str, format_args args);
+ void init(int err_code, string_view format_str, format_args args);
+
+ protected:
+ int error_code_;
+
+ system_error() : std::runtime_error(""), error_code_(0) {}
public:
/**
\rst
- Constructs a :class:`fmt::windows_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".
+ Constructs a :class:`fmt::system_error` object with a description
+ formatted with `fmt::format_system_error`. *message* and additional
+ arguments passed into the constructor are formatted similarly to
+ `fmt::format`.
**Example**::
- // This throws a windows_error with the description
- // cannot open file 'madeup': The system cannot find the file specified.
+ // This throws a system_error with the description
+ // cannot open file 'madeup': No such file or directory
// 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);
- }
+ std::FILE *file = std::fopen(filename, "r");
+ if (!file)
+ throw fmt::system_error(errno, "cannot open file '{}'", filename);
\endrst
*/
template <typename... Args>
- windows_error(int error_code, string_view message, const Args&... args) {
+ system_error(int error_code, string_view message, const Args&... args)
+ : std::runtime_error("") {
init(error_code, message, make_format_args(args...));
}
+ system_error(const system_error&) = default;
+ system_error& operator=(const system_error&) = default;
+ system_error(system_error&&) = default;
+ system_error& operator=(system_error&&) = default;
+ ~system_error() FMT_NOEXCEPT FMT_OVERRIDE;
+
+ int error_code() const { return error_code_; }
};
-// Reports a Windows error without throwing an exception.
-// Can be used to report errors from destructors.
-FMT_API void report_windows_error(int error_code,
- string_view message) FMT_NOEXCEPT;
+/**
+ \rst
+ Formats an error returned by an operating system or a language runtime,
+ for example a file opening error, and writes it to *out* in the following
+ form:
-#endif
+ .. 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``.
+ If *error_code* is not a valid error code such as -1, the system message
+ may look like "Unknown error -1" and is platform-dependent.
+ \endrst
+ */
+FMT_API void format_system_error(detail::buffer<char>& out, int error_code,
+ string_view message) FMT_NOEXCEPT;
+
+// Reports a system error without throwing an exception.
+// Can be used to report errors from destructors.
+FMT_API void report_system_error(int error_code,
+ string_view message) FMT_NOEXCEPT;
/** Fast integer formatter. */
class format_int {
private:
// Buffer should be large enough to hold all digits (digits10 + 1),
// a sign and a null character.
- enum { BUFFER_SIZE = std::numeric_limits<unsigned long long>::digits10 + 3 };
- mutable char buffer_[BUFFER_SIZE];
+ enum { buffer_size = std::numeric_limits<unsigned long long>::digits10 + 3 };
+ mutable char buffer_[buffer_size];
char* str_;
// Formats value in reverse and returns a pointer to the beginning.
char* format_decimal(unsigned long long value) {
- char* ptr = buffer_ + (BUFFER_SIZE - 1); // Parens to workaround MSVC bug.
+ char* ptr = buffer_ + (buffer_size - 1); // Parens to workaround MSVC bug.
while (value >= 100) {
// Integer division is slow so do it for a group of two digits instead
// of for every digit. The idea comes from the talk by Alexandrescu
// "Three Optimization Tips for C++". See speed-test for a comparison.
- unsigned index = static_cast<unsigned>((value % 100) * 2);
+ auto index = static_cast<unsigned>((value % 100) * 2);
value /= 100;
- *--ptr = internal::data::DIGITS[index + 1];
- *--ptr = internal::data::DIGITS[index];
+ *--ptr = detail::data::digits[index + 1];
+ *--ptr = detail::data::digits[index];
}
if (value < 10) {
*--ptr = static_cast<char>('0' + value);
return ptr;
}
- unsigned index = static_cast<unsigned>(value * 2);
- *--ptr = internal::data::DIGITS[index + 1];
- *--ptr = internal::data::DIGITS[index];
+ auto index = static_cast<unsigned>(value * 2);
+ *--ptr = detail::data::digits[index + 1];
+ *--ptr = detail::data::digits[index];
return ptr;
}
void format_signed(long long value) {
- unsigned long long abs_value = static_cast<unsigned long long>(value);
+ auto abs_value = static_cast<unsigned long long>(value);
bool negative = value < 0;
if (negative) abs_value = 0 - abs_value;
str_ = format_decimal(abs_value);
explicit format_int(unsigned long long value) : str_(format_decimal(value)) {}
/** Returns the number of characters written to the output buffer. */
- std::size_t size() const {
- return internal::to_unsigned(buffer_ - str_ + BUFFER_SIZE - 1);
+ size_t size() const {
+ return detail::to_unsigned(buffer_ - str_ + buffer_size - 1);
}
/**
character appended.
*/
const char* c_str() const {
- buffer_[BUFFER_SIZE - 1] = '\0';
+ buffer_[buffer_size - 1] = '\0';
return str_;
}
std::string str() const { return std::string(str_, size()); }
};
-// Formats a decimal integer value writing into buffer and returns
-// a pointer to the end of the formatted string. This function doesn't
-// write a terminating null character.
-template <typename T>
-FMT_DEPRECATED inline void format_decimal(char*& buffer, T value) {
- typedef typename internal::int_traits<T>::main_type main_type;
- main_type abs_value = static_cast<main_type>(value);
- if (internal::is_negative(value)) {
- *buffer++ = '-';
- abs_value = 0 - abs_value;
- }
- if (abs_value < 100) {
- if (abs_value < 10) {
- *buffer++ = static_cast<char>('0' + abs_value);
- return;
- }
- unsigned index = static_cast<unsigned>(abs_value * 2);
- *buffer++ = internal::data::DIGITS[index];
- *buffer++ = internal::data::DIGITS[index + 1];
- return;
- }
- int num_digits = internal::count_digits(abs_value);
- internal::format_decimal<char>(
- internal::make_checked(buffer, internal::to_unsigned(num_digits)),
- abs_value, num_digits);
- buffer += num_digits;
-}
-
-// Formatter of objects of type T.
+// A formatter specialization for the core types corresponding to detail::type
+// constants.
template <typename T, typename Char>
struct formatter<T, Char,
- typename std::enable_if<internal::format_type<
- typename buffer_context<Char>::type, T>::value>::type> {
- FMT_CONSTEXPR formatter() : format_str_(FMT_NULL) {}
+ enable_if_t<detail::type_constant<T, Char>::value !=
+ detail::type::custom_type>> {
+ FMT_CONSTEXPR formatter() = default;
// Parses format specifiers stopping either at the end of the range or at the
// terminating '}'.
template <typename ParseContext>
- FMT_CONSTEXPR typename ParseContext::iterator parse(ParseContext& ctx) {
- format_str_ = ctx.begin();
- typedef internal::dynamic_specs_handler<ParseContext> handler_type;
- auto type =
- internal::get_type<typename buffer_context<Char>::type, T>::value;
- internal::specs_checker<handler_type> handler(handler_type(specs_, ctx),
- type);
+ FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
+ using handler_type = detail::dynamic_specs_handler<ParseContext>;
+ auto type = detail::type_constant<T, Char>::value;
+ detail::specs_checker<handler_type> handler(handler_type(specs_, ctx),
+ type);
auto it = parse_format_specs(ctx.begin(), ctx.end(), handler);
- auto type_spec = specs_.type;
auto eh = ctx.error_handler();
switch (type) {
- case internal::none_type:
- case internal::named_arg_type:
+ case detail::type::none_type:
FMT_ASSERT(false, "invalid argument type");
break;
- case internal::int_type:
- case internal::uint_type:
- case internal::long_long_type:
- case internal::ulong_long_type:
- case internal::bool_type:
- handle_int_type_spec(type_spec,
- internal::int_type_checker<decltype(eh)>(eh));
+ case detail::type::int_type:
+ case detail::type::uint_type:
+ case detail::type::long_long_type:
+ case detail::type::ulong_long_type:
+ case detail::type::int128_type:
+ case detail::type::uint128_type:
+ case detail::type::bool_type:
+ handle_int_type_spec(specs_.type,
+ detail::int_type_checker<decltype(eh)>(eh));
break;
- case internal::char_type:
+ case detail::type::char_type:
handle_char_specs(
- &specs_, internal::char_specs_checker<decltype(eh)>(type_spec, eh));
+ &specs_, detail::char_specs_checker<decltype(eh)>(specs_.type, eh));
+ break;
+ case detail::type::float_type:
+ if (detail::const_check(FMT_USE_FLOAT))
+ detail::parse_float_type_spec(specs_, eh);
+ else
+ FMT_ASSERT(false, "float support disabled");
+ break;
+ case detail::type::double_type:
+ if (detail::const_check(FMT_USE_DOUBLE))
+ detail::parse_float_type_spec(specs_, eh);
+ else
+ FMT_ASSERT(false, "double support disabled");
break;
- case internal::double_type:
- case internal::long_double_type:
- handle_float_type_spec(type_spec,
- internal::float_type_checker<decltype(eh)>(eh));
+ case detail::type::long_double_type:
+ if (detail::const_check(FMT_USE_LONG_DOUBLE))
+ detail::parse_float_type_spec(specs_, eh);
+ else
+ FMT_ASSERT(false, "long double support disabled");
break;
- case internal::cstring_type:
- internal::handle_cstring_type_spec(
- type_spec, internal::cstring_type_checker<decltype(eh)>(eh));
+ case detail::type::cstring_type:
+ detail::handle_cstring_type_spec(
+ specs_.type, detail::cstring_type_checker<decltype(eh)>(eh));
break;
- case internal::string_type:
- internal::check_string_type_spec(type_spec, eh);
+ case detail::type::string_type:
+ detail::check_string_type_spec(specs_.type, eh);
break;
- case internal::pointer_type:
- internal::check_pointer_type_spec(type_spec, eh);
+ case detail::type::pointer_type:
+ detail::check_pointer_type_spec(specs_.type, eh);
break;
- case internal::custom_type:
+ case detail::type::custom_type:
// Custom format specifiers should be checked in parse functions of
// formatter specializations.
break;
template <typename FormatContext>
auto format(const T& val, FormatContext& ctx) -> decltype(ctx.out()) {
- internal::handle_dynamic_spec<internal::width_checker>(
- specs_.width_, specs_.width_ref, ctx, format_str_);
- internal::handle_dynamic_spec<internal::precision_checker>(
- specs_.precision, specs_.precision_ref, ctx, format_str_);
- typedef output_range<typename FormatContext::iterator,
- typename FormatContext::char_type>
- range_type;
- return visit_format_arg(arg_formatter<range_type>(ctx, FMT_NULL, &specs_),
- internal::make_arg<FormatContext>(val));
+ 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);
+ using range_type = detail::output_range<typename FormatContext::iterator,
+ typename FormatContext::char_type>;
+ return visit_format_arg(arg_formatter<range_type>(ctx, nullptr, &specs_),
+ detail::make_arg<FormatContext>(val));
}
private:
- internal::dynamic_format_specs<Char> specs_;
- const Char* format_str_;
+ detail::dynamic_format_specs<Char> specs_;
+};
+
+#define FMT_FORMAT_AS(Type, Base) \
+ template <typename Char> \
+ struct formatter<Type, Char> : formatter<Base, Char> { \
+ template <typename FormatContext> \
+ auto format(Type const& val, FormatContext& ctx) -> decltype(ctx.out()) { \
+ return formatter<Base, Char>::format(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>
+struct formatter<void*, Char> : formatter<const void*, Char> {
+ template <typename FormatContext>
+ auto format(void* val, FormatContext& ctx) -> decltype(ctx.out()) {
+ return formatter<const void*, Char>::format(val, ctx);
+ }
+};
+
+template <typename Char, size_t N>
+struct formatter<Char[N], Char> : formatter<basic_string_view<Char>, Char> {
+ template <typename FormatContext>
+ auto format(const Char* val, FormatContext& ctx) -> decltype(ctx.out()) {
+ return formatter<basic_string_view<Char>, Char>::format(val, ctx);
+ }
};
// A formatter for types known only at run time such as variant alternatives.
//
// Usage:
-// typedef std::variant<int, std::string> variant;
+// using variant = std::variant<int, std::string>;
// template <>
// struct formatter<variant>: dynamic_formatter<> {
// void format(buffer &buf, const variant &v, context &ctx) {
// };
template <typename Char = char> class dynamic_formatter {
private:
- struct null_handler : internal::error_handler {
- void on_align(alignment) {}
+ struct null_handler : detail::error_handler {
+ void on_align(align_t) {}
void on_plus() {}
void on_minus() {}
void on_space() {}
auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
format_str_ = ctx.begin();
// Checks are deferred to formatting time when the argument type is known.
-
internal::dynamic_specs_handler<ParseContext> handler(specs_, ctx);
+
detail::dynamic_specs_handler<ParseContext> handler(specs_, ctx);
return parse_format_specs(ctx.begin(), ctx.end(), handler);
}
template <typename T, typename FormatContext>
auto format(const T& val, FormatContext& ctx) -> decltype(ctx.out()) {
handle_specs(ctx);
- internal::specs_checker<null_handler> checker(
- null_handler(), internal::get_type<FormatContext, T>::value);
- checker.on_align(specs_.align());
- if (specs_.flags == 0)
- ; // Do nothing.
- else if (specs_.has(SIGN_FLAG))
- specs_.has(PLUS_FLAG) ? checker.on_plus() : checker.on_space();
- else if (specs_.has(MINUS_FLAG))
+ detail::specs_checker<null_handler> checker(
+ null_handler(), detail::mapped_type_constant<T, FormatContext>::value);
+ checker.on_align(specs_.align);
+ switch (specs_.sign) {
+ case sign::none:
+ break;
+ case sign::plus:
+ checker.on_plus();
+ break;
+ case sign::minus:
checker.on_minus();
- else if (specs_.has(HASH_FLAG))
- checker.on_hash();
- if (specs_.precision != -1) checker.end_precision();
- typedef output_range<typename FormatContext::iterator,
- typename FormatContext::char_type>
- range;
- visit_format_arg(arg_formatter<range>(ctx, FMT_NULL, &specs_),
- internal::make_arg<FormatContext>(val));
+ break;
+ case sign::space:
+ checker.on_space();
+ break;
+ }
+ if (specs_.alt) checker.on_hash();
+ if (specs_.precision >= 0) checker.end_precision();
+ using range = detail::output_range<typename FormatContext::iterator,
+ typename FormatContext::char_type>;
+ visit_format_arg(arg_formatter<range>(ctx, nullptr, &specs_),
+ detail::make_arg<FormatContext>(val));
return ctx.out();
}
private:
template <typename Context> void handle_specs(Context& ctx) {
- internal::handle_dynamic_spec<internal::width_checker>(
- specs_.width_, specs_.width_ref, ctx, format_str_);
- internal::handle_dynamic_spec<internal::precision_checker>(
- specs_.precision, specs_.precision_ref, ctx, format_str_);
+ 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);
}
- internal::dynamic_format_specs<Char> specs_;
+ detail::dynamic_format_specs<Char> specs_;
const Char* format_str_;
};
-template <typename Range, typename Char>
-typename basic_format_context<Range, Char>::format_arg
-basic_format_context<Range, Char>::arg(basic_string_view<char_type> name) {
- map_.init(args_);
- format_arg arg = map_.find(name);
- if (arg.type() == internal::none_type) this->on_error("argument not found");
- return arg;
+template <typename Char, typename ErrorHandler>
+FMT_CONSTEXPR void advance_to(
+ basic_format_parse_context<Char, ErrorHandler>& ctx, const Char* p) {
+ ctx.advance_to(ctx.begin() + (p - &*ctx.begin()));
}
template <typename ArgFormatter, typename Char, typename Context>
-struct format_handler : internal::error_handler {
- typedef typename ArgFormatter::range range;
+struct format_handler : detail::error_handler {
+ using range = typename ArgFormatter::range;
format_handler(range r, basic_string_view<Char> str,
- basic_format_args<Context> format_args,
- internal::locale_ref loc)
+ basic_format_args<Context> format_args, detail::locale_ref loc)
: parse_context(str), context(r.begin(), format_args, loc) {}
void on_text(const Char* begin, const Char* end) {
- auto size = internal::to_unsigned(end - begin);
+ auto size = detail::to_unsigned(end - begin);
auto out = context.out();
- auto&& it = internal::reserve(out, size);
+ auto&& it = detail::reserve(out, size);
it = std::copy_n(begin, size, it);
context.advance_to(out);
}
- void get_arg(unsigned id) { arg = internal::get_arg(context, id); }
+ template <typename ID> void get_arg(ID id) {
+ arg = detail::get_arg(context, id);
+ }
void on_arg_id() { get_arg(parse_context.next_arg_id()); }
- void on_arg_id(unsigned id) {
+ void on_arg_id(int id) {
parse_context.check_arg_id(id);
get_arg(id);
}
- void on_arg_id(basic_string_view<Char> id) { arg = context.arg(id); }
+ void on_arg_id(basic_string_view<Char> id) { get_arg(id); }
void on_replacement_field(const Char* p) {
- parse_context.advance_to(p);
- internal::custom_formatter<Context> f(parse_context, context);
- if (!visit_format_arg(f, arg))
- context.advance_to(
- visit_format_arg(ArgFormatter(context, &parse_context), arg));
+ advance_to(parse_context, p);
+ context.advance_to(
+ visit_format_arg(ArgFormatter(context, &parse_context), arg));
}
const Char* on_format_specs(const Char* begin, const Char* end) {
- parse_context.advance_to(begin);
- internal::custom_formatter<Context> f(parse_context, context);
+ advance_to(parse_context, begin);
+ detail::custom_formatter<Context> f(parse_context, context);
if (visit_format_arg(f, arg)) return parse_context.begin();
basic_format_specs<Char> specs;
- using internal::specs_handler;
- typedef basic_parse_context<Char> parse_context_t;
-
internal::specs_checker<specs_handler<parse_context_t, Context>> handler(
+ using detail::specs_handler;
+ using parse_context_t = basic_format_parse_context<Char>;
+
detail::specs_checker<specs_handler<parse_context_t, Context>> handler(
specs_handler<parse_context_t, Context>(specs, parse_context, context),
arg.type());
begin = parse_format_specs(begin, end, handler);
if (begin == end || *begin != '}') on_error("missing '}' in format string");
- parse_context.advance_to(begin);
+ advance_to(parse_context, begin);
context.advance_to(
visit_format_arg(ArgFormatter(context, &parse_context, &specs), arg));
return begin;
}
- basic_parse_context<Char> parse_context;
+ basic_format_parse_context<Char> parse_context;
Context context;
basic_format_arg<Context> arg;
};
typename Context::iterator vformat_to(
typename ArgFormatter::range out, basic_string_view<Char> format_str,
basic_format_args<Context> args,
- internal::locale_ref loc = internal::locale_ref()) {
+ detail::locale_ref loc = detail::locale_ref()) {
format_handler<ArgFormatter, Char, Context> h(out, format_str, args, loc);
- internal::parse_format_string<false>(format_str, h);
+ if (format_str.size() == 2 && format_str[0] == '{' && format_str[1] == '}') {
+ auto arg = detail::get_arg(h.context, 0);
+ h.parse_context.advance_to(&format_str[1]);
+ return visit_format_arg(ArgFormatter(h.context, &h.parse_context), arg);
+ }
+ detail::parse_format_string<false>(format_str, h);
return h.context.out();
}
// Example:
// auto s = format("{}", ptr(p));
template <typename T> inline const void* ptr(const T* p) { return p; }
+template <typename T> inline const void* ptr(const std::unique_ptr<T>& p) {
+ return p.get();
+}
+template <typename T> inline const void* ptr(const std::shared_ptr<T>& p) {
+ return p.get();
+}
+
+class bytes {
+ private:
+ string_view data_;
+ friend struct formatter<bytes>;
+
+ public:
+ explicit bytes(string_view data) : data_(data) {}
+};
+
+template <> struct formatter<bytes> {
+ template <typename ParseContext>
+ FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
+ using handler_type = detail::dynamic_specs_handler<ParseContext>;
+ detail::specs_checker<handler_type> handler(handler_type(specs_, ctx),
+ detail::type::string_type);
+ auto it = parse_format_specs(ctx.begin(), ctx.end(), handler);
+ detail::check_string_type_spec(specs_.type, ctx.error_handler());
+ return it;
+ }
+
+ 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);
+ detail::handle_dynamic_spec<detail::precision_checker>(
+ specs_.precision, specs_.precision_ref, ctx);
+ return detail::write_bytes(ctx.out(), b.data_, specs_);
+ }
+
+ private:
+ detail::dynamic_format_specs<char> specs_;
+};
-template <typename It, typename Char> struct arg_join {
+template <typename It, typename Sentinel, typename Char>
+struct arg_join : detail::view {
It begin;
- It end;
+ Sentinel end;
basic_string_view<Char> sep;
- arg_join(It begin, It end, basic_string_view<Char> sep)
- : begin(begin), end(end), sep(sep) {}
+ arg_join(It b, Sentinel e, basic_string_view<Char> s)
+ : begin(b), end(e), sep(s) {}
};
-template <typename It, typename Char>
-struct formatter<arg_join<It, Char>, Char>
+template <typename It, typename Sentinel, typename Char>
+struct formatter<arg_join<It, Sentinel, Char>, Char>
: formatter<typename std::iterator_traits<It>::value_type, Char> {
template <typename FormatContext>
- auto format(const arg_join<It, Char>& value, FormatContext& ctx)
+ auto format(const arg_join<It, Sentinel, Char>& value, FormatContext& ctx)
-> decltype(ctx.out()) {
- typedef formatter<typename std::iterator_traits<It>::value_type, Char> base;
+ using base = formatter<typename std::iterator_traits<It>::value_type, Char>;
auto it = value.begin;
auto out = ctx.out();
if (it != value.end) {
}
};
-template <typename It>
-arg_join<It, char> join(It begin, It end, string_view sep) {
- return arg_join<It, char>(begin, end, sep);
+/**
+ Returns an object that formats the iterator range `[begin, end)` with elements
+ separated by `sep`.
+ */
+template <typename It, typename Sentinel>
+arg_join<It, Sentinel, char> join(It begin, Sentinel end, string_view sep) {
+ return {begin, end, sep};
}
-template <typename It>
-arg_join<It, wchar_t> join(It begin, It end, wstring_view sep) {
- return arg_join<It, wchar_t>(begin, end, sep);
+template <typename It, typename Sentinel>
+arg_join<It, Sentinel, wchar_t> join(It begin, Sentinel end, wstring_view sep) {
+ return {begin, end, sep};
}
-// The following causes ICE in gcc 4.4.
-#if FMT_USE_TRAILING_RETURN && (!FMT_GCC_VERSION || FMT_GCC_VERSION >= 405)
+/**
+ \rst
+ Returns an object 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::
+
+ fmt::print("{:02}", fmt::join(v, ", "));
+ // Output: "01, 02, 03"
+ \endrst
+ */
template <typename Range>
-auto join(const Range& range, string_view sep)
- -> arg_join<decltype(internal::begin(range)), char> {
- return join(internal::begin(range), internal::end(range), sep);
+arg_join<detail::iterator_t<const Range>, detail::sentinel_t<const Range>, char>
+join(const Range& range, string_view sep) {
+ return join(std::begin(range), std::end(range), sep);
}
template <typename Range>
-auto join(const Range& range, wstring_view sep)
- -> arg_join<decltype(internal::begin(range)), wchar_t> {
- return join(internal::begin(range), internal::end(range), sep);
+arg_join<detail::iterator_t<const Range>, detail::sentinel_t<const Range>,
+ wchar_t>
+join(const Range& range, wstring_view sep) {
+ return join(std::begin(range), std::end(range), sep);
}
-#endif
/**
\rst
Converts *value* to ``std::string`` using the default format for type *T*.
- It doesn't support user-defined types with custom formatters.
**Example**::
std::string answer = fmt::to_string(42);
\endrst
*/
-template <typename T> std::string to_string(const T& value) {
- std::string str;
- internal::container_buffer<std::string> buf(str);
- writer(buf).write(value);
- return str;
+template <typename T> inline std::string to_string(const T& value) {
+ return format("{}", value);
}
/**
Converts *value* to ``std::wstring`` using the default format for type *T*.
*/
-template <typename T> std::wstring to_wstring(const T& value) {
- std::wstring str;
- internal::container_buffer<std::wstring> buf(str);
- wwriter(buf).write(value);
- return str;
+template <typename T> inline std::wstring to_wstring(const T& value) {
+ return format(L"{}", value);
}
-template <typename Char, std::size_t SIZE>
+template <typename Char, size_t SIZE>
std::basic_string<Char> to_string(const basic_memory_buffer<Char, SIZE>& buf) {
- return std::basic_string<Char>(buf.data(), buf.size());
+ auto size = buf.size();
+ detail::assume(size < std::basic_string<Char>().max_size());
+ return std::basic_string<Char>(buf.data(), size);
}
template <typename Char>
-typename buffer_context<Char>::type::iterator internal::vformat_to(
- internal::basic_buffer<Char>& buf, basic_string_view<Char> format_str,
- basic_format_args<typename buffer_context<Char>::type> args) {
- typedef back_insert_range<internal::basic_buffer<Char>> range;
+typename buffer_context<Char>::iterator detail::vformat_to(
+ detail::buffer<Char>& buf, basic_string_view<Char> format_str,
+ basic_format_args<buffer_context<type_identity_t<Char>>> args) {
+ using range = buffer_range<Char>;
return vformat_to<arg_formatter<range>>(buf, to_string_view(format_str),
args);
}
-template <typename S, typename Char = FMT_CHAR(S),
- FMT_ENABLE_IF(internal::is_string<S>::value)>
-inline typename buffer_context<Char>::type::iterator vformat_to(
- internal::basic_buffer<Char>& buf, const S& format_str,
- basic_format_args<typename buffer_context<Char>::type> args) {
- return internal::vformat_to(buf, to_string_view(format_str), args);
-}
+#ifndef FMT_HEADER_ONLY
+extern template format_context::iterator detail::vformat_to(
+ detail::buffer<char>&, string_view, basic_format_args<format_context>);
+namespace detail {
+extern template FMT_API std::string grouping_impl<char>(locale_ref loc);
+extern template FMT_API std::string grouping_impl<wchar_t>(locale_ref loc);
+extern template FMT_API char thousands_sep_impl<char>(locale_ref loc);
+extern template FMT_API wchar_t thousands_sep_impl<wchar_t>(locale_ref loc);
+extern template FMT_API char decimal_point_impl(locale_ref loc);
+extern template FMT_API wchar_t decimal_point_impl(locale_ref loc);
+extern template int format_float<double>(double value, int precision,
+ float_specs specs, buffer<char>& buf);
+extern template int format_float<long double>(long double value, int precision,
+ float_specs specs,
+ buffer<char>& buf);
+int snprintf_float(float value, int precision, float_specs specs,
+ buffer<char>& buf) = delete;
+extern template int snprintf_float<double>(double value, int precision,
+ float_specs specs,
+ buffer<char>& buf);
+extern template int snprintf_float<long double>(long double value,
+ int precision,
+ float_specs specs,
+ buffer<char>& buf);
+} // namespace detail
+#endif
-template <typename S, typename... Args, std::size_t SIZE = inline_buffer_size,
- typename Char = typename internal::char_t<S>::type>
-inline typename buffer_context<Char>::type::iterator format_to(
- basic_memory_buffer<Char, SIZE>& buf, const S& format_str,
- const Args&... args) {
- internal::check_format_string<Args...>(format_str);
- typedef typename buffer_context<Char>::type context;
- format_arg_store<context, Args...> as{args...};
- return internal::vformat_to(buf, to_string_view(format_str),
- basic_format_args<context>(as));
+template <typename S, typename Char = char_t<S>,
+ FMT_ENABLE_IF(detail::is_string<S>::value)>
+inline typename buffer_context<Char>::iterator vformat_to(
+ detail::buffer<Char>& buf, const S& format_str,
+ basic_format_args<buffer_context<type_identity_t<Char>>> args) {
+ return detail::vformat_to(buf, to_string_view(format_str), args);
}
-namespace internal {
-
-// Detect the iterator category of *any* given type in a SFINAE-friendly way.
-// Unfortunately, older implementations of std::iterator_traits are not safe
-// for use in a SFINAE-context.
-
-// the gist of C++17's void_t magic
-template <typename... Ts> struct void_ { typedef void type; };
-
-template <typename T, typename Enable = void>
-struct it_category : std::false_type {};
-
-template <typename T> struct it_category<T*> {
- typedef std::random_access_iterator_tag type;
-};
-
-template <typename T>
-struct it_category<T, typename void_<typename T::iterator_category>::type> {
- typedef typename T::iterator_category type;
-};
-
-// Detect if *any* given type models the OutputIterator concept.
-template <typename It> class is_output_iterator {
- // Check for mutability because all iterator categories derived from
- // std::input_iterator_tag *may* also meet the requirements of an
- // OutputIterator, thereby falling into the category of 'mutable iterators'
- // [iterator.requirements.general] clause 4.
- // The compiler reveals this property only at the point of *actually
- // dereferencing* the iterator!
- template <typename U>
- static decltype(*(internal::declval<U>())) test(std::input_iterator_tag);
- template <typename U> static char& test(std::output_iterator_tag);
- template <typename U> static const char& test(...);
-
- typedef decltype(test<It>(typename it_category<It>::type{})) type;
- typedef typename std::remove_reference<type>::type result;
-
- public:
- static const bool value = !std::is_const<result>::value;
-};
-} // namespace internal
+template <typename S, typename... Args, size_t SIZE = inline_buffer_size,
+ typename Char = enable_if_t<detail::is_string<S>::value, char_t<S>>>
+inline typename buffer_context<Char>::iterator format_to(
+ basic_memory_buffer<Char, SIZE>& buf, const S& format_str, Args&&... args) {
+ detail::check_format_string<Args...>(format_str);
+ using context = buffer_context<Char>;
+ return detail::vformat_to(buf, to_string_view(format_str),
+ make_format_args<context>(args...));
+}
template <typename OutputIt, typename Char = char>
-// using format_context_t = basic_format_context<OutputIt, Char>;
-struct format_context_t {
- typedef basic_format_context<OutputIt, Char> type;
-};
+using format_context_t = basic_format_context<OutputIt, Char>;
template <typename OutputIt, typename Char = char>
-// using format_args_t = basic_format_args<format_context_t<OutputIt, Char>>;
-struct format_args_t {
- typedef basic_format_args<typename format_context_t<OutputIt, Char>::type>
- type;
-};
+using format_args_t = basic_format_args<format_context_t<OutputIt, Char>>;
-template <typename String, typename OutputIt, typename... Args,
- FMT_ENABLE_IF(internal::is_output_iterator<OutputIt>::value)>
+template <
+ typename S, typename OutputIt, typename... Args,
+ FMT_ENABLE_IF(detail::is_output_iterator<OutputIt>::value &&
+ !detail::is_contiguous_back_insert_iterator<OutputIt>::value)>
inline OutputIt vformat_to(
- OutputIt out, const String& format_str,
- typename format_args_t<OutputIt, FMT_CHAR(String)>::type args) {
- typedef output_range<OutputIt, FMT_CHAR(String)> range;
+ OutputIt out, const S& format_str,
+ format_args_t<type_identity_t<OutputIt>, char_t<S>> args) {
+ using range = detail::output_range<OutputIt, char_t<S>>;
return vformat_to<arg_formatter<range>>(range(out),
to_string_view(format_str), args);
}
fmt::format_to(std::back_inserter(out), "{}", 42);
\endrst
*/
-template <typename OutputIt, typename S, typename... Args>
-inline
- typename std::enable_if<internal::is_string<S>::value &&
- internal::is_output_iterator<OutputIt>::value,
- OutputIt>::type
- format_to(OutputIt out, const S& format_str, const Args&... args) {
- internal::check_format_string<Args...>(format_str);
- typedef typename format_context_t<OutputIt, FMT_CHAR(S)>::type context;
- format_arg_store<context, Args...> as{args...};
+template <typename OutputIt, typename S, typename... Args,
+ FMT_ENABLE_IF(
+ detail::is_output_iterator<OutputIt>::value &&
+ !detail::is_contiguous_back_insert_iterator<OutputIt>::value &&
+ detail::is_string<S>::value)>
+inline OutputIt format_to(OutputIt out, const S& format_str, Args&&... args) {
+ detail::check_format_string<Args...>(format_str);
+ using context = format_context_t<OutputIt, char_t<S>>;
return vformat_to(out, to_string_view(format_str),
- basic_format_args<context>(as));
+ make_format_args<context>(args...));
}
template <typename OutputIt> struct format_to_n_result {
/** Iterator past the end of the output range. */
OutputIt out;
/** Total (not truncated) output size. */
- std::size_t size;
+ size_t size;
};
template <typename OutputIt, typename Char = typename OutputIt::value_type>
-struct format_to_n_context
- : format_context_t<fmt::internal::truncating_iterator<OutputIt>, Char> {};
+using format_to_n_context =
+ format_context_t<detail::truncating_iterator<OutputIt>, Char>;
template <typename OutputIt, typename Char = typename OutputIt::value_type>
-struct format_to_n_args {
- typedef basic_format_args<typename format_to_n_context<OutputIt, Char>::type>
- type;
-};
+using format_to_n_args = basic_format_args<format_to_n_context<OutputIt, Char>>;
template <typename OutputIt, typename Char, typename... Args>
-inline format_arg_store<typename format_to_n_context<OutputIt, Char>::type,
- Args...>
+inline format_arg_store<format_to_n_context<OutputIt, Char>, Args...>
make_format_to_n_args(const Args&... args) {
- return format_arg_store<typename format_to_n_context<OutputIt, Char>::type,
- Args...>(args...);
+ return format_arg_store<format_to_n_context<OutputIt, Char>, Args...>(
+ args...);
}
template <typename OutputIt, typename Char, typename... Args,
- FMT_ENABLE_IF(internal::is_output_iterator<OutputIt>::value)>
+ FMT_ENABLE_IF(detail::is_output_iterator<OutputIt>::value)>
inline format_to_n_result<OutputIt> vformat_to_n(
- OutputIt out, std::size_t n, basic_string_view<Char> format_str,
- typename format_to_n_args<OutputIt, Char>::type args) {
- typedef internal::truncating_iterator<OutputIt> It;
- auto it = vformat_to(It(out, n), format_str, args);
+ OutputIt out, size_t n, basic_string_view<Char> format_str,
+ format_to_n_args<type_identity_t<OutputIt>, type_identity_t<Char>> args) {
+ auto it = vformat_to(detail::truncating_iterator<OutputIt>(out, n),
+ format_str, args);
return {it.base(), it.count()};
}
\endrst
*/
template <typename OutputIt, typename S, typename... Args,
- FMT_ENABLE_IF(internal::is_string<S>::value&&
- internal::is_output_iterator<OutputIt>::value)>
-inline format_to_n_result<OutputIt> format_to_n(OutputIt out, std::size_t n,
+ FMT_ENABLE_IF(detail::is_string<S>::value&&
+ detail::is_output_iterator<OutputIt>::value)>
+inline format_to_n_result<OutputIt> format_to_n(OutputIt out, size_t n,
const S& format_str,
const Args&... args) {
- internal::check_format_string<Args...>(format_str);
- typedef FMT_CHAR(S) Char;
- format_arg_store<typename format_to_n_context<OutputIt, Char>::type, Args...>
- as(args...);
+ detail::check_format_string<Args...>(format_str);
+ using context = format_to_n_context<OutputIt, char_t<S>>;
return vformat_to_n(out, n, to_string_view(format_str),
- typename format_to_n_args<OutputIt, Char>::type(as));
+ make_format_args<context>(args...));
}
template <typename Char>
-inline std::basic_string<Char> internal::vformat(
+std::basic_string<Char> detail::vformat(
basic_string_view<Char> format_str,
- basic_format_args<typename buffer_context<Char>::type> args) {
+ basic_format_args<buffer_context<type_identity_t<Char>>> args) {
basic_memory_buffer<Char> buffer;
- internal::vformat_to(buffer, format_str, args);
- return fmt::to_string(buffer);
+ detail::vformat_to(buffer, format_str, args);
+ return to_string(buffer);
}
/**
``format(format_str, args...)``.
*/
template <typename... Args>
-inline std::size_t formatted_size(string_view format_str, const Args&... args) {
- auto it = format_to(internal::counting_iterator<char>(), format_str, args...);
- return it.count();
+inline size_t formatted_size(string_view format_str, const Args&... args) {
+ return format_to(detail::counting_iterator(), format_str, args...).count();
+}
+
+template <typename Char, FMT_ENABLE_IF(std::is_same<Char, wchar_t>::value)>
+void vprint(std::FILE* f, basic_string_view<Char> format_str,
+ wformat_args args) {
+ wmemory_buffer buffer;
+ detail::vformat_to(buffer, format_str, args);
+ buffer.push_back(L'\0');
+ if (std::fputws(buffer.data(), f) == -1)
+ FMT_THROW(system_error(errno, "cannot write to file"));
+}
+
+template <typename Char, FMT_ENABLE_IF(std::is_same<Char, wchar_t>::value)>
+void vprint(basic_string_view<Char> format_str, wformat_args args) {
+ vprint(stdout, format_str, args);
}
#if FMT_USE_USER_DEFINED_LITERALS
-namespace internal {
+namespace detail {
-# if FMT_UDL_TEMPLATE
+# if FMT_USE_UDL_TEMPLATE
template <typename Char, Char... CHARS> class udl_formatter {
public:
template <typename... Args>
- std::basic_string<Char> operator()(const Args&... args) const {
- FMT_CONSTEXPR_DECL Char s[] = {CHARS..., '\0'};
- FMT_CONSTEXPR_DECL bool invalid_format =
- do_check_format_string<Char, error_handler, Args...>(
- basic_string_view<Char>(s, sizeof...(CHARS)));
- (void)invalid_format;
- return format(s, args...);
+ std::basic_string<Char> operator()(Args&&... args) const {
+ static FMT_CONSTEXPR_DECL Char s[] = {CHARS..., '\0'};
+ check_format_string<remove_cvref_t<Args>...>(FMT_STRING(s));
+ return format(s, std::forward<Args>(args)...);
}
};
# else
template <typename Char> struct udl_formatter {
- const Char* str;
+ basic_string_view<Char> str;
template <typename... Args>
- auto operator()(Args&&... args) const
- -> decltype(format(str, std::forward<Args>(args)...)) {
+ std::basic_string<Char> operator()(Args&&... args) const {
return format(str, std::forward<Args>(args)...);
}
};
-# endif // FMT_UDL_TEMPLATE
+# endif // FMT_USE_UDL_TEMPLATE
template <typename Char> struct udl_arg {
const Char* str;
- template <typename T> named_arg<T, Char> operator=(T&& value) const {
+ template <typename T> named_arg<Char, T> operator=(T&& value) const {
return {str, std::forward<T>(value)};
}
};
-
-} // namespace internal
+} // namespace detail
inline namespace literals {
-# if FMT_UDL_TEMPLATE
+# if FMT_USE_UDL_TEMPLATE
+# pragma GCC diagnostic push
+# pragma GCC diagnostic ignored "-Wpedantic"
+# if FMT_CLANG_VERSION
+# pragma GCC diagnostic ignored "-Wgnu-string-literal-operator-template"
+# endif
template <typename Char, Char... CHARS>
-FMT_CONSTEXPR internal::udl_formatter<Char, CHARS...> operator""_format() {
+FMT_CONSTEXPR detail::udl_formatter<Char, CHARS...> operator""_format() {
return {};
}
+# pragma GCC diagnostic pop
# else
/**
\rst
std::string message = "The answer is {}"_format(42);
\endrst
*/
-inline internal::udl_formatter<char> operator"" _format(const char* s,
- std::size_t) {
- return {s};
+FMT_CONSTEXPR detail::udl_formatter<char> operator"" _format(const char* s,
+ size_t n) {
+ return {{s, n}};
}
-inline internal::udl_formatter<wchar_t> operator"" _format(const wchar_t* s,
- std::size_t) {
- return {s};
+FMT_CONSTEXPR detail::udl_formatter<wchar_t> operator"" _format(
+ const wchar_t* s, size_t n) {
+ return {{s, n}};
}
-# endif // FMT_UDL_TEMPLATE
+# endif // FMT_USE_UDL_TEMPLATE
/**
\rst
fmt::print("Elapsed time: {s:.2f} seconds", "s"_a=1.23);
\endrst
*/
-inline internal::udl_arg<char> operator"" _a(const char* s, std::size_t) {
+FMT_CONSTEXPR detail::udl_arg<char> operator"" _a(const char* s, size_t) {
return {s};
}
-inline internal::udl_arg<wchar_t> operator"" _a(const wchar_t* s, std::size_t) {
+FMT_CONSTEXPR detail::udl_arg<wchar_t> operator"" _a(const wchar_t* s, size_t) {
return {s};
}
} // namespace literals
#endif // FMT_USE_USER_DEFINED_LITERALS
FMT_END_NAMESPACE
-/**
- \rst
- Constructs a compile-time format string.
-
- **Example**::
-
- // A compile-time error because 'd' is an invalid specifier for strings.
- std::string s = format(FMT_STRING("{:d}"), "foo");
- \endrst
- */
-#define FMT_STRING(s) \
- [] { \
- struct str : fmt::compile_string { \
- typedef typename std::remove_cv<std::remove_pointer< \
- typename std::decay<decltype(s)>::type>::type>::type char_type; \
- FMT_CONSTEXPR operator fmt::basic_string_view<char_type>() const { \
- return {s, sizeof(s) / sizeof(char_type) - 1}; \
- } \
- } result; \
- /* Suppress Qt Creator warning about unused operator. */ \
- (void)static_cast<fmt::basic_string_view<typename str::char_type>>( \
- result); \
- return result; \
- }()
-
-#if defined(FMT_STRING_ALIAS) && FMT_STRING_ALIAS
-/**
- \rst
- Constructs a compile-time format string. This macro is disabled by default to
- prevent potential name collisions. To enable it define ``FMT_STRING_ALIAS`` to
- 1 before including ``fmt/format.h``.
-
- **Example**::
-
- #define FMT_STRING_ALIAS 1
- #include <fmt/format.h>
- // A compile-time error because 'd' is an invalid specifier for strings.
- std::string s = format(fmt("{:d}"), "foo");
- \endrst
- */
-# define fmt(s) FMT_STRING(s)
-#endif
-
#ifdef FMT_HEADER_ONLY
# define FMT_FUNC inline
# include "format-inl.h"
# define FMT_FUNC
#endif
-// Restore warnings.
-#if FMT_GCC_VERSION >= 406 || FMT_CLANG_VERSION
-# pragma GCC diagnostic pop
-#endif
-
#endif // FMT_FORMAT_H_
projects / ceph.git / blobdiff