2012-12-07 16:31:09 +00:00
|
|
|
/*
|
2014-05-03 16:48:54 +00:00
|
|
|
Formatting library for C++
|
2012-12-12 15:44:41 +00:00
|
|
|
|
2015-03-04 05:04:45 +00:00
|
|
|
Copyright (c) 2012 - 2015, Victor Zverovich
|
2012-12-12 15:44:41 +00:00
|
|
|
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.
|
2012-12-07 16:31:09 +00:00
|
|
|
*/
|
|
|
|
|
2014-04-24 00:33:50 +00:00
|
|
|
#ifndef FMT_FORMAT_H_
|
|
|
|
#define FMT_FORMAT_H_
|
2012-12-07 16:31:09 +00:00
|
|
|
|
2013-01-08 17:56:05 +00:00
|
|
|
#include <stdint.h>
|
|
|
|
|
2014-04-25 15:18:07 +00:00
|
|
|
#include <cassert>
|
2014-09-19 14:51:42 +00:00
|
|
|
#include <cmath>
|
2014-04-24 19:37:06 +00:00
|
|
|
#include <cstddef> // for std::ptrdiff_t
|
2012-12-18 23:50:14 +00:00
|
|
|
#include <cstdio>
|
2013-04-22 15:11:57 +00:00
|
|
|
#include <algorithm>
|
2013-09-09 17:42:33 +00:00
|
|
|
#include <limits>
|
2012-12-07 16:31:09 +00:00
|
|
|
#include <stdexcept>
|
|
|
|
#include <string>
|
2012-12-09 17:03:47 +00:00
|
|
|
#include <sstream>
|
2015-06-10 01:32:59 +00:00
|
|
|
#include <map>
|
2012-12-07 16:31:09 +00:00
|
|
|
|
2014-06-23 16:49:59 +00:00
|
|
|
#if _SECURE_SCL
|
|
|
|
# include <iterator>
|
|
|
|
#endif
|
2015-02-20 16:49:06 +00:00
|
|
|
|
2015-02-20 03:19:01 +00:00
|
|
|
#ifdef _MSC_VER
|
2015-02-20 16:49:06 +00:00
|
|
|
# include <intrin.h> // _BitScanReverse, _BitScanReverse64
|
|
|
|
|
|
|
|
namespace fmt {
|
|
|
|
namespace internal {
|
|
|
|
# pragma intrinsic(_BitScanReverse)
|
2015-02-21 14:16:49 +00:00
|
|
|
inline uint32_t clz(uint32_t x) {
|
2015-02-20 16:51:01 +00:00
|
|
|
unsigned long r = 0;
|
|
|
|
_BitScanReverse(&r, x);
|
|
|
|
return 31 - r;
|
|
|
|
}
|
2015-02-21 14:16:49 +00:00
|
|
|
# define FMT_BUILTIN_CLZ(n) fmt::internal::clz(n)
|
2015-02-25 11:40:28 +00:00
|
|
|
|
|
|
|
# ifdef _WIN64
|
2015-02-25 14:17:12 +00:00
|
|
|
# pragma intrinsic(_BitScanReverse64)
|
2015-02-25 11:40:28 +00:00
|
|
|
# endif
|
|
|
|
|
2015-02-22 14:31:55 +00:00
|
|
|
inline uint32_t clzll(uint64_t x) {
|
2015-02-20 16:49:06 +00:00
|
|
|
unsigned long r = 0;
|
2015-02-22 09:43:58 +00:00
|
|
|
# ifdef _WIN64
|
2015-02-20 16:49:06 +00:00
|
|
|
_BitScanReverse64(&r, x);
|
2015-02-22 09:43:58 +00:00
|
|
|
# else
|
|
|
|
// Scan the high 32 bits.
|
2015-02-22 14:31:55 +00:00
|
|
|
if (_BitScanReverse(&r, static_cast<uint32_t>(x >> 32)))
|
2015-02-22 09:43:58 +00:00
|
|
|
return 63 - (r + 32);
|
|
|
|
|
|
|
|
// Scan the low 32 bits.
|
2015-02-22 14:31:55 +00:00
|
|
|
_BitScanReverse(&r, static_cast<uint32_t>(x));
|
2015-02-22 09:43:58 +00:00
|
|
|
# endif
|
2015-02-20 16:49:06 +00:00
|
|
|
return 63 - r;
|
|
|
|
}
|
2015-02-21 14:16:49 +00:00
|
|
|
# define FMT_BUILTIN_CLZLL(n) fmt::internal::clzll(n)
|
2015-02-20 16:49:06 +00:00
|
|
|
}
|
|
|
|
}
|
2015-02-20 03:19:01 +00:00
|
|
|
#endif
|
2014-06-23 16:49:59 +00:00
|
|
|
|
2013-12-09 16:31:08 +00:00
|
|
|
#ifdef __GNUC__
|
2013-12-10 01:51:11 +00:00
|
|
|
# define FMT_GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__)
|
2014-02-15 18:17:10 +00:00
|
|
|
# define FMT_GCC_EXTENSION __extension__
|
2014-04-16 16:19:31 +00:00
|
|
|
# if FMT_GCC_VERSION >= 406
|
|
|
|
# pragma GCC diagnostic push
|
2014-12-09 15:45:54 +00:00
|
|
|
// Disable the warning about "long long" which is sometimes reported even
|
|
|
|
// when using __extension__.
|
2014-04-16 16:19:31 +00:00
|
|
|
# pragma GCC diagnostic ignored "-Wlong-long"
|
2014-12-09 15:45:54 +00:00
|
|
|
// Disable the warning about declaration shadowing because it affects too
|
|
|
|
// many valid cases.
|
|
|
|
# pragma GCC diagnostic ignored "-Wshadow"
|
2014-04-16 16:19:31 +00:00
|
|
|
# endif
|
2015-02-15 07:25:56 +00:00
|
|
|
# if __cplusplus >= 201103L || defined __GXX_EXPERIMENTAL_CXX0X__
|
|
|
|
# define FMT_HAS_GXX_CXX11 1
|
|
|
|
# endif
|
2014-02-15 18:41:00 +00:00
|
|
|
#else
|
|
|
|
# define FMT_GCC_EXTENSION
|
2013-12-09 16:12:33 +00:00
|
|
|
#endif
|
|
|
|
|
2015-02-07 05:25:30 +00:00
|
|
|
#ifdef __clang__
|
2015-03-19 15:04:31 +00:00
|
|
|
# pragma clang diagnostic push
|
2015-02-26 01:32:32 +00:00
|
|
|
# pragma clang diagnostic ignored "-Wdocumentation"
|
2015-02-07 05:25:30 +00:00
|
|
|
#endif
|
|
|
|
|
2014-07-02 04:01:15 +00:00
|
|
|
#ifdef __GNUC_LIBSTD__
|
2014-04-24 21:18:37 +00:00
|
|
|
# define FMT_GNUC_LIBSTD_VERSION (__GNUC_LIBSTD__ * 100 + __GNUC_LIBSTD_MINOR__)
|
|
|
|
#endif
|
|
|
|
|
2014-04-24 00:33:50 +00:00
|
|
|
#ifdef __has_feature
|
|
|
|
# define FMT_HAS_FEATURE(x) __has_feature(x)
|
|
|
|
#else
|
|
|
|
# define FMT_HAS_FEATURE(x) 0
|
2014-06-11 08:30:57 +00:00
|
|
|
#endif
|
|
|
|
|
2014-06-11 12:52:02 +00:00
|
|
|
#ifdef __has_builtin
|
2014-06-11 08:30:57 +00:00
|
|
|
# define FMT_HAS_BUILTIN(x) __has_builtin(x)
|
|
|
|
#else
|
2014-04-24 00:33:50 +00:00
|
|
|
# define FMT_HAS_BUILTIN(x) 0
|
2013-05-15 17:04:11 +00:00
|
|
|
#endif
|
|
|
|
|
2015-02-07 14:51:47 +00:00
|
|
|
#ifdef __has_cpp_attribute
|
|
|
|
# define FMT_HAS_CPP_ATTRIBUTE(x) __has_cpp_attribute(x)
|
|
|
|
#else
|
|
|
|
# define FMT_HAS_CPP_ATTRIBUTE(x) 0
|
|
|
|
#endif
|
|
|
|
|
2014-03-06 20:06:44 +00:00
|
|
|
#ifndef FMT_USE_VARIADIC_TEMPLATES
|
2014-04-24 14:30:06 +00:00
|
|
|
// Variadic templates are available in GCC since version 4.4
|
|
|
|
// (http://gcc.gnu.org/projects/cxx0x.html) and in Visual C++
|
|
|
|
// since version 2013.
|
2014-03-06 20:06:44 +00:00
|
|
|
# define FMT_USE_VARIADIC_TEMPLATES \
|
2014-04-24 00:33:50 +00:00
|
|
|
(FMT_HAS_FEATURE(cxx_variadic_templates) || \
|
2015-02-15 03:16:23 +00:00
|
|
|
(FMT_GCC_VERSION >= 404 && FMT_HAS_GXX_CXX11) || _MSC_VER >= 1800)
|
2014-03-06 20:06:44 +00:00
|
|
|
#endif
|
|
|
|
|
2014-04-24 14:30:39 +00:00
|
|
|
#ifndef FMT_USE_RVALUE_REFERENCES
|
2014-04-24 21:18:37 +00:00
|
|
|
// Don't use rvalue references when compiling with clang and an old libstdc++
|
|
|
|
// as the latter doesn't provide std::move.
|
2014-04-24 22:39:20 +00:00
|
|
|
# if defined(FMT_GNUC_LIBSTD_VERSION) && FMT_GNUC_LIBSTD_VERSION <= 402
|
2014-04-24 21:18:37 +00:00
|
|
|
# define FMT_USE_RVALUE_REFERENCES 0
|
2014-04-26 13:47:25 +00:00
|
|
|
# else
|
|
|
|
# define FMT_USE_RVALUE_REFERENCES \
|
|
|
|
(FMT_HAS_FEATURE(cxx_rvalue_references) || \
|
2015-02-15 03:16:23 +00:00
|
|
|
(FMT_GCC_VERSION >= 403 && FMT_HAS_GXX_CXX11) || _MSC_VER >= 1600)
|
2014-04-24 21:18:37 +00:00
|
|
|
# endif
|
2014-04-24 14:30:39 +00:00
|
|
|
#endif
|
|
|
|
|
2014-04-24 19:37:06 +00:00
|
|
|
#if FMT_USE_RVALUE_REFERENCES
|
|
|
|
# include <utility> // for std::move
|
|
|
|
#endif
|
|
|
|
|
2014-07-02 04:01:15 +00:00
|
|
|
// Define FMT_USE_NOEXCEPT to make C++ Format use noexcept (C++11 feature).
|
2015-06-22 16:24:54 +00:00
|
|
|
#ifndef FMT_NOEXCEPT
|
|
|
|
# if FMT_USE_NOEXCEPT || FMT_HAS_FEATURE(cxx_noexcept) || \
|
|
|
|
(FMT_GCC_VERSION >= 408 && FMT_HAS_GXX_CXX11)
|
|
|
|
# define FMT_NOEXCEPT noexcept
|
|
|
|
# else
|
|
|
|
# define FMT_NOEXCEPT throw()
|
|
|
|
# endif
|
2013-05-15 15:59:44 +00:00
|
|
|
#endif
|
|
|
|
|
2014-04-27 16:46:56 +00:00
|
|
|
// A macro to disallow the copy constructor and operator= functions
|
|
|
|
// This should be used in the private: declarations for a class
|
2015-02-14 15:22:14 +00:00
|
|
|
#if FMT_USE_DELETED_FUNCTIONS || FMT_HAS_FEATURE(cxx_deleted_functions) || \
|
2015-02-15 03:16:23 +00:00
|
|
|
(FMT_GCC_VERSION >= 404 && FMT_HAS_GXX_CXX11) || _MSC_VER >= 1800
|
2015-06-10 01:32:59 +00:00
|
|
|
# define FMT_DELETED_OR_UNDEFINED = delete
|
2015-02-14 15:22:14 +00:00
|
|
|
# define FMT_DISALLOW_COPY_AND_ASSIGN(TypeName) \
|
|
|
|
TypeName(const TypeName&) = delete; \
|
|
|
|
TypeName& operator=(const TypeName&) = delete
|
|
|
|
#else
|
2015-06-10 01:32:59 +00:00
|
|
|
# define FMT_DELETED_OR_UNDEFINED
|
2015-02-14 15:22:14 +00:00
|
|
|
# define FMT_DISALLOW_COPY_AND_ASSIGN(TypeName) \
|
|
|
|
TypeName(const TypeName&); \
|
|
|
|
TypeName& operator=(const TypeName&)
|
|
|
|
#endif
|
2014-04-27 16:46:56 +00:00
|
|
|
|
2015-06-22 15:17:23 +00:00
|
|
|
#ifndef FMT_ASSERT
|
|
|
|
# define FMT_ASSERT(condition, message) assert((condition) && message)
|
|
|
|
#endif
|
|
|
|
|
2013-01-21 19:42:25 +00:00
|
|
|
namespace fmt {
|
2012-12-07 16:31:09 +00:00
|
|
|
|
2014-02-15 17:58:33 +00:00
|
|
|
// Fix the warning about long long on older versions of GCC
|
|
|
|
// that don't support the diagnostic pragma.
|
2014-02-15 18:17:10 +00:00
|
|
|
FMT_GCC_EXTENSION typedef long long LongLong;
|
|
|
|
FMT_GCC_EXTENSION typedef unsigned long long ULongLong;
|
2014-02-15 17:58:33 +00:00
|
|
|
|
2014-06-28 21:48:42 +00:00
|
|
|
#if FMT_USE_RVALUE_REFERENCES
|
|
|
|
using std::move;
|
|
|
|
#endif
|
|
|
|
|
2014-09-29 15:48:16 +00:00
|
|
|
template <typename Char>
|
2014-04-23 15:27:50 +00:00
|
|
|
class BasicWriter;
|
|
|
|
|
2014-04-30 13:55:21 +00:00
|
|
|
typedef BasicWriter<char> Writer;
|
|
|
|
typedef BasicWriter<wchar_t> WWriter;
|
|
|
|
|
2014-07-08 23:20:33 +00:00
|
|
|
template <typename Char>
|
2014-07-08 23:38:50 +00:00
|
|
|
class BasicFormatter;
|
2014-07-08 23:20:33 +00:00
|
|
|
|
2014-07-04 14:18:44 +00:00
|
|
|
template <typename Char, typename T>
|
2014-08-29 14:23:54 +00:00
|
|
|
void format(BasicFormatter<Char> &f, const Char *&format_str, const T &value);
|
2014-07-04 14:18:44 +00:00
|
|
|
|
2014-04-30 13:55:21 +00:00
|
|
|
/**
|
|
|
|
\rst
|
2015-06-26 14:43:54 +00:00
|
|
|
A string reference. It can be constructed from a C string or ``std::string``.
|
2014-06-29 18:51:10 +00:00
|
|
|
|
|
|
|
You can use one of the following typedefs for common character types:
|
|
|
|
|
|
|
|
+------------+-------------------------+
|
|
|
|
| Type | Definition |
|
|
|
|
+============+=========================+
|
|
|
|
| StringRef | BasicStringRef<char> |
|
|
|
|
+------------+-------------------------+
|
|
|
|
| WStringRef | BasicStringRef<wchar_t> |
|
|
|
|
+------------+-------------------------+
|
|
|
|
|
|
|
|
This class is most useful as a parameter type to allow passing
|
|
|
|
different types of strings to a function, for example::
|
2014-04-30 13:55:21 +00:00
|
|
|
|
2014-09-24 14:48:45 +00:00
|
|
|
template <typename... Args>
|
2014-12-09 15:45:54 +00:00
|
|
|
std::string format(StringRef format_str, const Args & ... args);
|
2014-04-30 13:55:21 +00:00
|
|
|
|
2014-06-28 21:48:42 +00:00
|
|
|
format("{}", 42);
|
|
|
|
format(std::string("{}"), 42);
|
2014-04-30 13:55:21 +00:00
|
|
|
\endrst
|
|
|
|
*/
|
|
|
|
template <typename Char>
|
|
|
|
class BasicStringRef {
|
|
|
|
private:
|
|
|
|
const Char *data_;
|
2014-10-30 14:05:42 +00:00
|
|
|
std::size_t size_;
|
2014-04-30 13:55:21 +00:00
|
|
|
|
|
|
|
public:
|
2015-06-26 14:43:54 +00:00
|
|
|
/** Constructs a string reference object from a C string and a size. */
|
2014-10-30 14:10:43 +00:00
|
|
|
BasicStringRef(const Char *s, std::size_t size) : data_(s), size_(size) {}
|
2014-10-30 14:05:42 +00:00
|
|
|
|
|
|
|
/**
|
2015-05-22 14:08:16 +00:00
|
|
|
\rst
|
2014-10-30 14:05:42 +00:00
|
|
|
Constructs a string reference object from a C string computing
|
|
|
|
the size with ``std::char_traits<Char>::length``.
|
2015-05-22 14:08:16 +00:00
|
|
|
\endrst
|
2014-10-30 14:05:42 +00:00
|
|
|
*/
|
|
|
|
BasicStringRef(const Char *s)
|
|
|
|
: data_(s), size_(std::char_traits<Char>::length(s)) {}
|
2014-04-30 13:55:21 +00:00
|
|
|
|
|
|
|
/**
|
2015-05-22 14:08:16 +00:00
|
|
|
\rst
|
|
|
|
Constructs a string reference from an ``std::string`` object.
|
|
|
|
\endrst
|
2014-04-30 13:55:21 +00:00
|
|
|
*/
|
|
|
|
BasicStringRef(const std::basic_string<Char> &s)
|
|
|
|
: data_(s.c_str()), size_(s.size()) {}
|
|
|
|
|
|
|
|
/**
|
2015-05-22 14:08:16 +00:00
|
|
|
\rst
|
|
|
|
Converts a string reference to an ``std::string`` object.
|
|
|
|
\endrst
|
2014-04-30 13:55:21 +00:00
|
|
|
*/
|
2015-06-17 14:59:41 +00:00
|
|
|
std::basic_string<Char> to_string() const {
|
2015-06-26 14:43:54 +00:00
|
|
|
return std::basic_string<Char>(data_, size_);
|
2014-04-30 13:55:21 +00:00
|
|
|
}
|
|
|
|
|
2015-06-26 14:43:54 +00:00
|
|
|
/** Returns the pointer to a C string. */
|
|
|
|
const Char *data() const { return data_; }
|
2014-04-30 13:55:21 +00:00
|
|
|
|
2015-06-26 14:43:54 +00:00
|
|
|
/** Returns the string size. */
|
2014-10-30 14:05:42 +00:00
|
|
|
std::size_t size() const { return size_; }
|
2014-07-03 15:50:57 +00:00
|
|
|
|
|
|
|
friend bool operator==(BasicStringRef lhs, BasicStringRef rhs) {
|
|
|
|
return lhs.data_ == rhs.data_;
|
|
|
|
}
|
|
|
|
friend bool operator!=(BasicStringRef lhs, BasicStringRef rhs) {
|
|
|
|
return lhs.data_ != rhs.data_;
|
|
|
|
}
|
2015-06-10 01:32:59 +00:00
|
|
|
friend bool operator<(BasicStringRef lhs, BasicStringRef rhs) {
|
2015-06-26 14:43:54 +00:00
|
|
|
return std::lexicographical_compare(
|
|
|
|
lhs.data_, lhs.data_ + lhs.size_, rhs.data_, rhs.data_ + rhs.size_);
|
2015-06-10 01:32:59 +00:00
|
|
|
}
|
2014-04-30 13:55:21 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
typedef BasicStringRef<char> StringRef;
|
|
|
|
typedef BasicStringRef<wchar_t> WStringRef;
|
|
|
|
|
2015-06-26 14:43:54 +00:00
|
|
|
/**
|
|
|
|
\rst
|
|
|
|
A reference to a null terminated string. It can be constructed from a C
|
|
|
|
string or ``std::string``.
|
|
|
|
|
|
|
|
You can use one of the following typedefs for common character types:
|
|
|
|
|
|
|
|
+-------------+--------------------------+
|
|
|
|
| Type | Definition |
|
|
|
|
+=============+==========================+
|
|
|
|
| CStringRef | BasicCStringRef<char> |
|
|
|
|
+-------------+--------------------------+
|
|
|
|
| WCStringRef | BasicCStringRef<wchar_t> |
|
|
|
|
+-------------+--------------------------+
|
|
|
|
|
|
|
|
This class is most useful as a parameter type to allow passing
|
|
|
|
different types of strings to a function, for example::
|
|
|
|
|
|
|
|
template <typename... Args>
|
|
|
|
std::string format(CStringRef format_str, const Args & ... args);
|
|
|
|
|
|
|
|
format("{}", 42);
|
|
|
|
format(std::string("{}"), 42);
|
|
|
|
\endrst
|
|
|
|
*/
|
|
|
|
template <typename Char>
|
|
|
|
class BasicCStringRef {
|
|
|
|
private:
|
|
|
|
const Char *data_;
|
|
|
|
|
|
|
|
public:
|
|
|
|
/** Constructs a string reference object from a C string. */
|
|
|
|
BasicCStringRef(const Char *s) : data_(s) {}
|
|
|
|
|
|
|
|
/**
|
|
|
|
\rst
|
|
|
|
Constructs a string reference from an ``std::string`` object.
|
|
|
|
\endrst
|
|
|
|
*/
|
|
|
|
BasicCStringRef(const std::basic_string<Char> &s) : data_(s.c_str()) {}
|
|
|
|
|
|
|
|
/** Returns the pointer to a C string. */
|
|
|
|
const Char *c_str() const { return data_; }
|
|
|
|
};
|
|
|
|
|
|
|
|
typedef BasicCStringRef<char> CStringRef;
|
|
|
|
typedef BasicCStringRef<wchar_t> WCStringRef;
|
|
|
|
|
2014-06-06 13:38:37 +00:00
|
|
|
/**
|
|
|
|
A formatting error such as invalid format string.
|
|
|
|
*/
|
|
|
|
class FormatError : public std::runtime_error {
|
2015-02-24 16:31:56 +00:00
|
|
|
public:
|
2015-06-26 14:43:54 +00:00
|
|
|
explicit FormatError(CStringRef message)
|
2014-08-29 15:16:10 +00:00
|
|
|
: std::runtime_error(message.c_str()) {}
|
2014-06-06 13:38:37 +00:00
|
|
|
};
|
|
|
|
|
2012-12-12 17:14:00 +00:00
|
|
|
namespace internal {
|
2014-09-29 15:48:16 +00:00
|
|
|
// The number of characters to store in the MemoryBuffer object itself
|
|
|
|
// to avoid dynamic memory allocation.
|
2014-04-09 15:05:23 +00:00
|
|
|
enum { INLINE_BUFFER_SIZE = 500 };
|
2012-12-12 17:14:00 +00:00
|
|
|
|
2013-09-03 15:16:53 +00:00
|
|
|
#if _SECURE_SCL
|
2014-04-29 13:54:46 +00:00
|
|
|
// Use checked iterator to avoid warnings on MSVC.
|
2013-09-03 03:24:09 +00:00
|
|
|
template <typename T>
|
2014-07-25 15:41:22 +00:00
|
|
|
inline stdext::checked_array_iterator<T*> make_ptr(T *ptr, std::size_t size) {
|
2013-09-03 03:24:09 +00:00
|
|
|
return stdext::checked_array_iterator<T*>(ptr, size);
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
template <typename T>
|
2014-07-25 15:41:22 +00:00
|
|
|
inline T *make_ptr(T *ptr, std::size_t) { return ptr; }
|
2013-09-03 15:16:53 +00:00
|
|
|
#endif
|
2015-03-20 13:31:24 +00:00
|
|
|
} // namespace internal
|
2013-09-03 15:16:53 +00:00
|
|
|
|
2015-05-22 14:08:16 +00:00
|
|
|
/**
|
|
|
|
\rst
|
|
|
|
A buffer supporting a subset of ``std::vector``'s operations.
|
|
|
|
\endrst
|
|
|
|
*/
|
2014-09-29 15:48:16 +00:00
|
|
|
template <typename T>
|
|
|
|
class Buffer {
|
2012-12-11 01:16:08 +00:00
|
|
|
private:
|
2014-09-29 15:48:16 +00:00
|
|
|
FMT_DISALLOW_COPY_AND_ASSIGN(Buffer);
|
|
|
|
|
|
|
|
protected:
|
|
|
|
T *ptr_;
|
2012-12-11 01:16:08 +00:00
|
|
|
std::size_t size_;
|
|
|
|
std::size_t capacity_;
|
|
|
|
|
2014-09-29 15:48:16 +00:00
|
|
|
Buffer(T *ptr = 0, std::size_t capacity = 0)
|
|
|
|
: ptr_(ptr), size_(0), capacity_(capacity) {}
|
2012-12-11 01:16:08 +00:00
|
|
|
|
2015-03-20 13:31:24 +00:00
|
|
|
/**
|
2015-05-22 14:08:16 +00:00
|
|
|
\rst
|
2015-03-20 13:31:24 +00:00
|
|
|
Increases the buffer capacity to hold at least *size* elements updating
|
|
|
|
``ptr_`` and ``capacity_``.
|
2015-05-22 14:08:16 +00:00
|
|
|
\endrst
|
2015-03-20 13:31:24 +00:00
|
|
|
*/
|
2014-09-29 15:48:16 +00:00
|
|
|
virtual void grow(std::size_t size) = 0;
|
2014-04-24 21:55:18 +00:00
|
|
|
|
2014-07-01 23:23:50 +00:00
|
|
|
public:
|
2014-09-29 15:48:16 +00:00
|
|
|
virtual ~Buffer() {}
|
2014-04-25 15:18:07 +00:00
|
|
|
|
2015-03-20 13:31:24 +00:00
|
|
|
/** Returns the size of this buffer. */
|
2012-12-11 01:16:08 +00:00
|
|
|
std::size_t size() const { return size_; }
|
2012-12-11 04:37:35 +00:00
|
|
|
|
2015-03-20 13:31:24 +00:00
|
|
|
/** Returns the capacity of this buffer. */
|
2012-12-11 01:16:08 +00:00
|
|
|
std::size_t capacity() const { return capacity_; }
|
|
|
|
|
2015-03-20 13:31:24 +00:00
|
|
|
/**
|
|
|
|
Resizes the buffer. If T is a POD type new elements may not be initialized.
|
|
|
|
*/
|
2012-12-11 02:08:04 +00:00
|
|
|
void resize(std::size_t new_size) {
|
|
|
|
if (new_size > capacity_)
|
2014-07-02 04:01:15 +00:00
|
|
|
grow(new_size);
|
2012-12-11 02:08:04 +00:00
|
|
|
size_ = new_size;
|
2012-12-11 01:16:08 +00:00
|
|
|
}
|
|
|
|
|
2015-05-22 14:08:16 +00:00
|
|
|
/**
|
|
|
|
\rst
|
|
|
|
Reserves space to store at least *capacity* elements.
|
|
|
|
\endrst
|
|
|
|
*/
|
2012-12-11 01:16:08 +00:00
|
|
|
void reserve(std::size_t capacity) {
|
2012-12-11 02:08:04 +00:00
|
|
|
if (capacity > capacity_)
|
2014-07-02 04:01:15 +00:00
|
|
|
grow(capacity);
|
2012-12-11 01:16:08 +00:00
|
|
|
}
|
|
|
|
|
2015-02-14 01:58:29 +00:00
|
|
|
void clear() FMT_NOEXCEPT { size_ = 0; }
|
2012-12-11 04:37:35 +00:00
|
|
|
|
2012-12-11 01:16:08 +00:00
|
|
|
void push_back(const T &value) {
|
|
|
|
if (size_ == capacity_)
|
2014-07-02 04:01:15 +00:00
|
|
|
grow(size_ + 1);
|
2012-12-11 01:16:08 +00:00
|
|
|
ptr_[size_++] = value;
|
|
|
|
}
|
|
|
|
|
2015-03-20 13:31:24 +00:00
|
|
|
/** Appends data to the end of the buffer. */
|
2015-06-09 15:20:44 +00:00
|
|
|
template <typename U>
|
|
|
|
void append(const U *begin, const U *end);
|
2012-12-11 01:16:08 +00:00
|
|
|
|
|
|
|
T &operator[](std::size_t index) { return ptr_[index]; }
|
|
|
|
const T &operator[](std::size_t index) const { return ptr_[index]; }
|
|
|
|
};
|
|
|
|
|
2014-09-29 15:48:16 +00:00
|
|
|
template <typename T>
|
2015-06-09 15:20:44 +00:00
|
|
|
template <typename U>
|
|
|
|
void Buffer<T>::append(const U *begin, const U *end) {
|
2014-09-29 15:48:16 +00:00
|
|
|
std::ptrdiff_t num_elements = end - begin;
|
|
|
|
if (size_ + num_elements > capacity_)
|
|
|
|
grow(size_ + num_elements);
|
2015-03-20 13:31:24 +00:00
|
|
|
std::copy(begin, end, internal::make_ptr(ptr_, capacity_) + size_);
|
2014-09-29 15:48:16 +00:00
|
|
|
size_ += num_elements;
|
|
|
|
}
|
|
|
|
|
2015-03-20 13:31:24 +00:00
|
|
|
namespace internal {
|
|
|
|
|
2014-09-29 15:48:16 +00:00
|
|
|
// A memory buffer for POD types with the first SIZE elements stored in
|
|
|
|
// the object itself.
|
|
|
|
template <typename T, std::size_t SIZE, typename Allocator = std::allocator<T> >
|
|
|
|
class MemoryBuffer : private Allocator, public Buffer<T> {
|
|
|
|
private:
|
|
|
|
T data_[SIZE];
|
|
|
|
|
|
|
|
// Free memory allocated by the buffer.
|
|
|
|
void free() {
|
|
|
|
if (this->ptr_ != data_) this->deallocate(this->ptr_, this->capacity_);
|
|
|
|
}
|
|
|
|
|
2014-10-01 15:12:10 +00:00
|
|
|
protected:
|
|
|
|
void grow(std::size_t size);
|
|
|
|
|
2014-09-29 15:48:16 +00:00
|
|
|
public:
|
|
|
|
explicit MemoryBuffer(const Allocator &alloc = Allocator())
|
|
|
|
: Allocator(alloc), Buffer<T>(data_, SIZE) {}
|
|
|
|
~MemoryBuffer() { free(); }
|
|
|
|
|
|
|
|
#if FMT_USE_RVALUE_REFERENCES
|
|
|
|
private:
|
|
|
|
// Move data from other to this buffer.
|
|
|
|
void move(MemoryBuffer &other) {
|
|
|
|
Allocator &this_alloc = *this, &other_alloc = other;
|
|
|
|
this_alloc = std::move(other_alloc);
|
|
|
|
this->size_ = other.size_;
|
|
|
|
this->capacity_ = other.capacity_;
|
|
|
|
if (other.ptr_ == other.data_) {
|
|
|
|
this->ptr_ = data_;
|
|
|
|
std::copy(other.data_,
|
|
|
|
other.data_ + this->size_, make_ptr(data_, this->capacity_));
|
|
|
|
} else {
|
|
|
|
this->ptr_ = other.ptr_;
|
|
|
|
// Set pointer to the inline array so that delete is not called
|
|
|
|
// when freeing.
|
|
|
|
other.ptr_ = other.data_;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
public:
|
|
|
|
MemoryBuffer(MemoryBuffer &&other) {
|
|
|
|
move(other);
|
|
|
|
}
|
|
|
|
|
|
|
|
MemoryBuffer &operator=(MemoryBuffer &&other) {
|
|
|
|
assert(this != &other);
|
|
|
|
free();
|
|
|
|
move(other);
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
// Returns a copy of the allocator associated with this buffer.
|
|
|
|
Allocator get_allocator() const { return *this; }
|
|
|
|
};
|
|
|
|
|
2014-09-18 16:07:40 +00:00
|
|
|
template <typename T, std::size_t SIZE, typename Allocator>
|
2014-09-29 15:48:16 +00:00
|
|
|
void MemoryBuffer<T, SIZE, Allocator>::grow(std::size_t size) {
|
|
|
|
std::size_t new_capacity =
|
|
|
|
(std::max)(size, this->capacity_ + this->capacity_ / 2);
|
2014-09-18 16:07:40 +00:00
|
|
|
T *new_ptr = this->allocate(new_capacity);
|
|
|
|
// The following code doesn't throw, so the raw pointer above doesn't leak.
|
2014-09-29 15:48:16 +00:00
|
|
|
std::copy(this->ptr_,
|
|
|
|
this->ptr_ + this->size_, make_ptr(new_ptr, new_capacity));
|
|
|
|
std::size_t old_capacity = this->capacity_;
|
|
|
|
T *old_ptr = this->ptr_;
|
|
|
|
this->capacity_ = new_capacity;
|
|
|
|
this->ptr_ = new_ptr;
|
2014-09-18 16:07:40 +00:00
|
|
|
// deallocate may throw (at least in principle), but it doesn't matter since
|
2014-09-29 15:48:16 +00:00
|
|
|
// the buffer already uses the new storage and will deallocate it in case
|
2014-09-18 16:07:40 +00:00
|
|
|
// of exception.
|
|
|
|
if (old_ptr != data_)
|
|
|
|
this->deallocate(old_ptr, old_capacity);
|
2012-12-11 02:08:04 +00:00
|
|
|
}
|
|
|
|
|
2015-03-02 02:08:24 +00:00
|
|
|
// A fixed-size buffer.
|
|
|
|
template <typename Char>
|
2015-03-20 13:31:24 +00:00
|
|
|
class FixedBuffer : public fmt::Buffer<Char> {
|
2015-03-02 02:08:24 +00:00
|
|
|
public:
|
2015-03-20 13:31:24 +00:00
|
|
|
FixedBuffer(Char *array, std::size_t size) : fmt::Buffer<Char>(array, size) {}
|
2015-03-02 02:08:24 +00:00
|
|
|
|
|
|
|
protected:
|
2015-03-02 02:19:56 +00:00
|
|
|
void grow(std::size_t size);
|
2015-03-02 02:08:24 +00:00
|
|
|
};
|
|
|
|
|
2014-09-19 14:51:42 +00:00
|
|
|
#ifndef _MSC_VER
|
|
|
|
// Portable version of signbit.
|
|
|
|
inline int getsign(double x) {
|
2014-10-05 16:34:46 +00:00
|
|
|
// When compiled in C++11 mode signbit is no longer a macro but a function
|
|
|
|
// defined in namespace std and the macro is undefined.
|
2014-09-19 14:51:42 +00:00
|
|
|
# ifdef signbit
|
|
|
|
return signbit(x);
|
|
|
|
# else
|
|
|
|
return std::signbit(x);
|
|
|
|
# endif
|
|
|
|
}
|
|
|
|
|
|
|
|
// Portable version of isinf.
|
|
|
|
# ifdef isinf
|
|
|
|
inline int isinfinity(double x) { return isinf(x); }
|
|
|
|
inline int isinfinity(long double x) { return isinf(x); }
|
|
|
|
# else
|
|
|
|
inline int isinfinity(double x) { return std::isinf(x); }
|
|
|
|
inline int isinfinity(long double x) { return std::isinf(x); }
|
|
|
|
# endif
|
|
|
|
#else
|
|
|
|
inline int getsign(double value) {
|
|
|
|
if (value < 0) return 1;
|
|
|
|
if (value == value) return 0;
|
|
|
|
int dec = 0, sign = 0;
|
|
|
|
char buffer[2]; // The buffer size must be >= 2 or _ecvt_s will fail.
|
|
|
|
_ecvt_s(buffer, sizeof(buffer), value, 0, &dec, &sign);
|
|
|
|
return sign;
|
|
|
|
}
|
|
|
|
inline int isinfinity(double x) { return !_finite(x); }
|
2015-04-30 15:41:17 +00:00
|
|
|
inline int isinfinity(long double x) {
|
|
|
|
return !_finite(static_cast<double>(x));
|
|
|
|
}
|
2014-09-19 14:51:42 +00:00
|
|
|
#endif
|
|
|
|
|
2014-02-14 18:36:17 +00:00
|
|
|
template <typename Char>
|
|
|
|
class BasicCharTraits {
|
|
|
|
public:
|
|
|
|
#if _SECURE_SCL
|
|
|
|
typedef stdext::checked_array_iterator<Char*> CharPtr;
|
|
|
|
#else
|
|
|
|
typedef Char *CharPtr;
|
|
|
|
#endif
|
2015-06-17 14:21:16 +00:00
|
|
|
static Char cast(wchar_t value) { return static_cast<Char>(value); }
|
2014-02-14 18:36:17 +00:00
|
|
|
};
|
|
|
|
|
2014-07-02 04:01:15 +00:00
|
|
|
template <typename Char>
|
|
|
|
class CharTraits;
|
|
|
|
|
2013-09-10 05:21:40 +00:00
|
|
|
template <>
|
2014-02-14 18:36:17 +00:00
|
|
|
class CharTraits<char> : public BasicCharTraits<char> {
|
2013-12-07 16:12:03 +00:00
|
|
|
private:
|
2014-07-02 15:38:31 +00:00
|
|
|
// Conversion from wchar_t to char is not allowed.
|
2014-07-04 14:18:44 +00:00
|
|
|
static char convert(wchar_t);
|
2013-12-07 16:12:03 +00:00
|
|
|
|
2015-06-15 14:15:28 +00:00
|
|
|
public:
|
2014-07-04 14:18:44 +00:00
|
|
|
static char convert(char value) { return value; }
|
2014-01-28 20:47:37 +00:00
|
|
|
|
2014-07-26 14:26:04 +00:00
|
|
|
// Formats a floating-point number.
|
2013-09-10 05:21:40 +00:00
|
|
|
template <typename T>
|
2014-07-26 15:03:03 +00:00
|
|
|
static int format_float(char *buffer, std::size_t size,
|
2013-09-10 05:21:40 +00:00
|
|
|
const char *format, unsigned width, int precision, T value);
|
|
|
|
};
|
|
|
|
|
|
|
|
template <>
|
2014-02-14 18:36:17 +00:00
|
|
|
class CharTraits<wchar_t> : public BasicCharTraits<wchar_t> {
|
2013-12-07 16:12:03 +00:00
|
|
|
public:
|
2014-07-04 14:18:44 +00:00
|
|
|
static wchar_t convert(char value) { return value; }
|
|
|
|
static wchar_t convert(wchar_t value) { return value; }
|
2013-09-10 05:21:40 +00:00
|
|
|
|
|
|
|
template <typename T>
|
2014-07-26 15:03:03 +00:00
|
|
|
static int format_float(wchar_t *buffer, std::size_t size,
|
2013-09-10 05:21:40 +00:00
|
|
|
const wchar_t *format, unsigned width, int precision, T value);
|
|
|
|
};
|
|
|
|
|
2014-02-20 15:43:37 +00:00
|
|
|
// Checks if a number is negative - used to avoid warnings.
|
|
|
|
template <bool IsSigned>
|
|
|
|
struct SignChecker {
|
|
|
|
template <typename T>
|
2014-09-29 15:48:16 +00:00
|
|
|
static bool is_negative(T value) { return value < 0; }
|
2013-01-13 17:41:14 +00:00
|
|
|
};
|
2013-01-13 15:14:54 +00:00
|
|
|
|
2014-02-20 15:43:37 +00:00
|
|
|
template <>
|
2014-09-29 15:48:16 +00:00
|
|
|
struct SignChecker<false> {
|
2014-02-20 15:43:37 +00:00
|
|
|
template <typename T>
|
2014-09-29 15:48:16 +00:00
|
|
|
static bool is_negative(T) { return false; }
|
2013-01-13 15:14:54 +00:00
|
|
|
};
|
|
|
|
|
2014-02-20 15:43:37 +00:00
|
|
|
// Returns true if value is negative, false otherwise.
|
|
|
|
// Same as (value < 0) but doesn't produce warnings if T is an unsigned type.
|
|
|
|
template <typename T>
|
2014-07-16 14:27:54 +00:00
|
|
|
inline bool is_negative(T value) {
|
|
|
|
return SignChecker<std::numeric_limits<T>::is_signed>::is_negative(value);
|
2014-02-20 15:43:37 +00:00
|
|
|
}
|
2013-01-13 15:14:54 +00:00
|
|
|
|
2014-09-29 15:48:16 +00:00
|
|
|
// Selects uint32_t if FitsIn32Bits is true, uint64_t otherwise.
|
|
|
|
template <bool FitsIn32Bits>
|
|
|
|
struct TypeSelector { typedef uint32_t Type; };
|
|
|
|
|
|
|
|
template <>
|
|
|
|
struct TypeSelector<false> { typedef uint64_t Type; };
|
|
|
|
|
2014-02-20 15:43:37 +00:00
|
|
|
template <typename T>
|
|
|
|
struct IntTraits {
|
|
|
|
// Smallest of uint32_t and uint64_t that is large enough to represent
|
|
|
|
// all values of T.
|
|
|
|
typedef typename
|
|
|
|
TypeSelector<std::numeric_limits<T>::digits <= 32>::Type MainType;
|
|
|
|
};
|
2013-09-09 22:23:05 +00:00
|
|
|
|
2014-07-31 14:43:14 +00:00
|
|
|
// MakeUnsigned<T>::Type gives an unsigned type corresponding to integer type T.
|
|
|
|
template <typename T>
|
|
|
|
struct MakeUnsigned { typedef T Type; };
|
|
|
|
|
2014-08-07 14:42:55 +00:00
|
|
|
#define FMT_SPECIALIZE_MAKE_UNSIGNED(T, U) \
|
2014-07-31 14:43:14 +00:00
|
|
|
template <> \
|
2014-08-01 04:23:49 +00:00
|
|
|
struct MakeUnsigned<T> { typedef U Type; }
|
|
|
|
|
2014-08-07 14:42:55 +00:00
|
|
|
FMT_SPECIALIZE_MAKE_UNSIGNED(char, unsigned char);
|
|
|
|
FMT_SPECIALIZE_MAKE_UNSIGNED(signed char, unsigned char);
|
|
|
|
FMT_SPECIALIZE_MAKE_UNSIGNED(short, unsigned short);
|
|
|
|
FMT_SPECIALIZE_MAKE_UNSIGNED(int, unsigned);
|
|
|
|
FMT_SPECIALIZE_MAKE_UNSIGNED(long, unsigned long);
|
|
|
|
FMT_SPECIALIZE_MAKE_UNSIGNED(LongLong, ULongLong);
|
2014-07-31 14:43:14 +00:00
|
|
|
|
2014-07-26 15:42:19 +00:00
|
|
|
void report_unknown_type(char code, const char *type);
|
2013-01-27 00:07:28 +00:00
|
|
|
|
2014-11-29 14:58:00 +00:00
|
|
|
// Static data is placed in this class template to allow header-only
|
|
|
|
// configuration.
|
|
|
|
template <typename T = void>
|
|
|
|
struct BasicData {
|
|
|
|
static const uint32_t POWERS_OF_10_32[];
|
|
|
|
static const uint64_t POWERS_OF_10_64[];
|
|
|
|
static const char DIGITS[];
|
|
|
|
};
|
|
|
|
|
|
|
|
typedef BasicData<> Data;
|
2014-02-14 18:36:17 +00:00
|
|
|
|
2015-02-20 16:49:06 +00:00
|
|
|
#if FMT_GCC_VERSION >= 400 || FMT_HAS_BUILTIN(__builtin_clz)
|
2015-02-20 16:58:16 +00:00
|
|
|
# define FMT_BUILTIN_CLZ(n) __builtin_clz(n)
|
2015-02-20 16:49:06 +00:00
|
|
|
#endif
|
|
|
|
|
|
|
|
#if FMT_GCC_VERSION >= 400 || FMT_HAS_BUILTIN(__builtin_clzll)
|
|
|
|
# define FMT_BUILTIN_CLZLL(n) __builtin_clzll(n)
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef FMT_BUILTIN_CLZLL
|
2013-08-31 18:14:43 +00:00
|
|
|
// Returns the number of decimal digits in n. Leading zeros are not counted
|
2014-07-24 15:59:52 +00:00
|
|
|
// except for n == 0 in which case count_digits returns 1.
|
|
|
|
inline unsigned count_digits(uint64_t n) {
|
2014-02-14 18:36:17 +00:00
|
|
|
// Based on http://graphics.stanford.edu/~seander/bithacks.html#IntegerLog10
|
|
|
|
// and the benchmark https://github.com/localvoid/cxx-benchmark-count-digits.
|
2015-02-20 16:49:06 +00:00
|
|
|
unsigned t = (64 - FMT_BUILTIN_CLZLL(n | 1)) * 1233 >> 12;
|
2014-11-29 14:58:00 +00:00
|
|
|
return t - (n < Data::POWERS_OF_10_64[t]) + 1;
|
2014-02-19 20:43:55 +00:00
|
|
|
}
|
2015-02-20 16:49:06 +00:00
|
|
|
#else
|
2014-09-24 14:59:23 +00:00
|
|
|
// Fallback version of count_digits used when __builtin_clz is not available.
|
2014-07-24 15:59:52 +00:00
|
|
|
inline unsigned count_digits(uint64_t n) {
|
2013-02-05 15:28:54 +00:00
|
|
|
unsigned 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;
|
|
|
|
}
|
|
|
|
}
|
2014-02-19 20:43:55 +00:00
|
|
|
#endif
|
2013-02-05 15:28:54 +00:00
|
|
|
|
2015-02-21 14:21:29 +00:00
|
|
|
#ifdef FMT_BUILTIN_CLZ
|
|
|
|
// Optional version of count_digits for better performance on 32-bit platforms.
|
|
|
|
inline unsigned count_digits(uint32_t n) {
|
|
|
|
uint32_t t = (32 - FMT_BUILTIN_CLZ(n | 1)) * 1233 >> 12;
|
|
|
|
return t - (n < Data::POWERS_OF_10_32[t]) + 1;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2014-02-17 17:12:24 +00:00
|
|
|
// Formats a decimal unsigned integer value writing into buffer.
|
|
|
|
template <typename UInt, typename Char>
|
2014-08-01 15:49:16 +00:00
|
|
|
inline void format_decimal(Char *buffer, UInt value, unsigned num_digits) {
|
2015-08-05 14:50:29 +00:00
|
|
|
buffer += num_digits;
|
2014-02-17 17:12:24 +00:00
|
|
|
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 = (value % 100) * 2;
|
|
|
|
value /= 100;
|
2015-08-05 14:50:29 +00:00
|
|
|
*--buffer = Data::DIGITS[index + 1];
|
|
|
|
*--buffer = Data::DIGITS[index];
|
2014-02-17 17:12:24 +00:00
|
|
|
}
|
|
|
|
if (value < 10) {
|
2015-08-05 14:50:29 +00:00
|
|
|
*--buffer = static_cast<char>('0' + value);
|
2014-02-17 17:12:24 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
unsigned index = static_cast<unsigned>(value * 2);
|
2015-08-05 14:50:29 +00:00
|
|
|
*--buffer = Data::DIGITS[index + 1];
|
|
|
|
*--buffer = Data::DIGITS[index];
|
2014-02-17 17:12:24 +00:00
|
|
|
}
|
2014-04-23 15:27:50 +00:00
|
|
|
|
2015-06-12 14:15:57 +00:00
|
|
|
#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
|
2014-04-30 14:23:43 +00:00
|
|
|
// A converter from UTF-8 to UTF-16.
|
2014-09-24 14:59:23 +00:00
|
|
|
// It is only provided for Windows since other systems support UTF-8 natively.
|
2014-04-30 14:23:43 +00:00
|
|
|
class UTF8ToUTF16 {
|
|
|
|
private:
|
2014-09-29 15:48:16 +00:00
|
|
|
MemoryBuffer<wchar_t, INLINE_BUFFER_SIZE> buffer_;
|
2014-04-30 14:23:43 +00:00
|
|
|
|
|
|
|
public:
|
|
|
|
explicit UTF8ToUTF16(StringRef s);
|
2014-04-30 14:38:43 +00:00
|
|
|
operator WStringRef() const { return WStringRef(&buffer_[0], size()); }
|
2014-04-30 14:23:43 +00:00
|
|
|
size_t size() const { return buffer_.size() - 1; }
|
2014-07-08 23:44:24 +00:00
|
|
|
const wchar_t *c_str() const { return &buffer_[0]; }
|
2014-07-01 01:26:46 +00:00
|
|
|
std::wstring str() const { return std::wstring(&buffer_[0], size()); }
|
2014-04-30 14:23:43 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
// A converter from UTF-16 to UTF-8.
|
2014-09-24 14:59:23 +00:00
|
|
|
// It is only provided for Windows since other systems support UTF-8 natively.
|
2014-04-30 14:23:43 +00:00
|
|
|
class UTF16ToUTF8 {
|
|
|
|
private:
|
2014-09-29 15:48:16 +00:00
|
|
|
MemoryBuffer<char, INLINE_BUFFER_SIZE> buffer_;
|
2014-04-30 14:23:43 +00:00
|
|
|
|
|
|
|
public:
|
|
|
|
UTF16ToUTF8() {}
|
|
|
|
explicit UTF16ToUTF8(WStringRef s);
|
2014-04-30 14:38:43 +00:00
|
|
|
operator StringRef() const { return StringRef(&buffer_[0], size()); }
|
2014-04-30 14:23:43 +00:00
|
|
|
size_t size() const { return buffer_.size() - 1; }
|
2014-07-08 23:44:24 +00:00
|
|
|
const char *c_str() const { return &buffer_[0]; }
|
2014-07-01 01:26:46 +00:00
|
|
|
std::string str() const { return std::string(&buffer_[0], size()); }
|
2014-04-30 14:23:43 +00:00
|
|
|
|
|
|
|
// Performs conversion returning a system error code instead of
|
2014-09-03 15:03:05 +00:00
|
|
|
// throwing exception on conversion error. This method may still throw
|
|
|
|
// in case of memory allocation error.
|
2014-07-27 19:53:42 +00:00
|
|
|
int convert(WStringRef s);
|
2014-04-30 14:23:43 +00:00
|
|
|
};
|
|
|
|
|
2014-09-03 15:03:05 +00:00
|
|
|
void format_windows_error(fmt::Writer &out, int error_code,
|
2015-02-14 01:58:29 +00:00
|
|
|
fmt::StringRef message) FMT_NOEXCEPT;
|
2014-04-30 22:00:41 +00:00
|
|
|
#endif
|
|
|
|
|
2015-06-12 14:15:57 +00:00
|
|
|
void format_system_error(fmt::Writer &out, int error_code,
|
|
|
|
fmt::StringRef message) FMT_NOEXCEPT;
|
|
|
|
|
2015-04-20 17:02:41 +00:00
|
|
|
// A formatting argument value.
|
|
|
|
struct Value {
|
2014-07-14 15:04:17 +00:00
|
|
|
template <typename Char>
|
|
|
|
struct StringValue {
|
|
|
|
const Char *value;
|
|
|
|
std::size_t size;
|
|
|
|
};
|
|
|
|
|
2014-06-24 14:54:26 +00:00
|
|
|
typedef void (*FormatFunc)(
|
2014-08-29 14:23:54 +00:00
|
|
|
void *formatter, const void *arg, void *format_str_ptr);
|
2014-06-24 14:54:26 +00:00
|
|
|
|
|
|
|
struct CustomValue {
|
|
|
|
const void *value;
|
|
|
|
FormatFunc format;
|
|
|
|
};
|
|
|
|
|
|
|
|
union {
|
|
|
|
int int_value;
|
|
|
|
unsigned uint_value;
|
|
|
|
LongLong long_long_value;
|
|
|
|
ULongLong ulong_long_value;
|
2014-07-02 15:38:31 +00:00
|
|
|
double double_value;
|
2014-06-24 14:54:26 +00:00
|
|
|
long double long_double_value;
|
2014-09-23 15:21:58 +00:00
|
|
|
const void *pointer;
|
2014-06-24 14:54:26 +00:00
|
|
|
StringValue<char> string;
|
2014-09-30 15:15:56 +00:00
|
|
|
StringValue<signed char> sstring;
|
|
|
|
StringValue<unsigned char> ustring;
|
2014-06-24 14:54:26 +00:00
|
|
|
StringValue<wchar_t> wstring;
|
|
|
|
CustomValue custom;
|
|
|
|
};
|
2014-06-30 13:19:20 +00:00
|
|
|
|
2014-09-23 14:59:43 +00:00
|
|
|
enum Type {
|
2015-06-10 01:32:59 +00:00
|
|
|
NONE, NAMED_ARG,
|
2014-09-23 14:59:43 +00:00
|
|
|
// Integer types should go first,
|
2015-06-11 16:00:06 +00:00
|
|
|
INT, UINT, LONG_LONG, ULONG_LONG, BOOL, CHAR, LAST_INTEGER_TYPE = CHAR,
|
2014-09-23 14:59:43 +00:00
|
|
|
// followed by floating-point types.
|
|
|
|
DOUBLE, LONG_DOUBLE, LAST_NUMERIC_TYPE = LONG_DOUBLE,
|
2014-09-25 14:10:44 +00:00
|
|
|
CSTRING, STRING, WSTRING, POINTER, CUSTOM
|
2014-09-23 14:59:43 +00:00
|
|
|
};
|
2015-04-20 17:02:41 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
// A formatting argument. It is a POD type to allow storage in
|
|
|
|
// internal::MemoryBuffer.
|
|
|
|
struct Arg : Value {
|
2014-09-23 14:59:43 +00:00
|
|
|
Type type;
|
|
|
|
};
|
|
|
|
|
2015-06-10 01:32:59 +00:00
|
|
|
template <typename Char>
|
|
|
|
struct NamedArg;
|
|
|
|
|
2015-03-16 15:43:33 +00:00
|
|
|
template <typename T = void>
|
2015-07-07 14:05:17 +00:00
|
|
|
struct Null {};
|
2015-02-25 15:43:47 +00:00
|
|
|
|
2015-02-26 00:03:00 +00:00
|
|
|
// A helper class template to enable or disable overloads taking wide
|
2015-03-27 14:36:26 +00:00
|
|
|
// characters and strings in MakeValue.
|
2015-02-25 15:43:47 +00:00
|
|
|
template <typename T, typename Char>
|
2015-02-26 00:03:00 +00:00
|
|
|
struct WCharHelper {
|
2015-07-07 14:05:17 +00:00
|
|
|
typedef Null<T> Supported;
|
2015-02-25 15:43:47 +00:00
|
|
|
typedef T Unsupported;
|
|
|
|
};
|
|
|
|
|
|
|
|
template <typename T>
|
2015-02-26 00:03:00 +00:00
|
|
|
struct WCharHelper<T, wchar_t> {
|
2015-02-25 15:43:47 +00:00
|
|
|
typedef T Supported;
|
2015-07-07 14:05:17 +00:00
|
|
|
typedef Null<T> Unsupported;
|
2015-02-25 15:43:47 +00:00
|
|
|
};
|
|
|
|
|
2015-03-10 14:53:46 +00:00
|
|
|
template <typename T>
|
|
|
|
class IsConvertibleToInt {
|
|
|
|
private:
|
|
|
|
typedef char yes[1];
|
|
|
|
typedef char no[2];
|
|
|
|
|
|
|
|
static const T &get();
|
|
|
|
|
2015-07-10 14:58:27 +00:00
|
|
|
static yes &convert(fmt::ULongLong);
|
|
|
|
static no &convert(...);
|
2015-03-18 03:12:36 +00:00
|
|
|
|
2015-03-10 14:53:46 +00:00
|
|
|
public:
|
2015-07-10 14:58:27 +00:00
|
|
|
enum { value = (sizeof(convert(get())) == sizeof(yes)) };
|
2015-03-10 14:53:46 +00:00
|
|
|
};
|
|
|
|
|
2015-03-19 01:59:09 +00:00
|
|
|
#define FMT_CONVERTIBLE_TO_INT(Type) \
|
|
|
|
template <> \
|
|
|
|
class IsConvertibleToInt<Type> { \
|
|
|
|
public: \
|
|
|
|
enum { value = 1 }; \
|
|
|
|
}
|
|
|
|
|
|
|
|
// Silence warnings about convering float to int.
|
|
|
|
FMT_CONVERTIBLE_TO_INT(float);
|
|
|
|
FMT_CONVERTIBLE_TO_INT(double);
|
|
|
|
FMT_CONVERTIBLE_TO_INT(long double);
|
|
|
|
|
2015-03-10 14:53:46 +00:00
|
|
|
template<bool B, class T = void>
|
|
|
|
struct EnableIf {};
|
|
|
|
|
|
|
|
template<class T>
|
|
|
|
struct EnableIf<true, T> { typedef T type; };
|
|
|
|
|
2015-04-20 17:02:41 +00:00
|
|
|
template<bool B, class T, class F>
|
|
|
|
struct Conditional { typedef T type; };
|
|
|
|
|
|
|
|
template<class T, class F>
|
|
|
|
struct Conditional<false, T, F> { typedef F type; };
|
|
|
|
|
2015-04-05 18:27:07 +00:00
|
|
|
// A helper function to suppress bogus "conditional expression is constant"
|
|
|
|
// warnings.
|
|
|
|
inline bool check(bool value) { return value; }
|
|
|
|
|
2015-03-25 13:48:21 +00:00
|
|
|
// Makes an Arg object from any type.
|
2014-07-01 16:15:20 +00:00
|
|
|
template <typename Char>
|
2015-03-27 14:36:26 +00:00
|
|
|
class MakeValue : public Arg {
|
2014-06-30 13:19:20 +00:00
|
|
|
private:
|
2014-07-03 15:50:57 +00:00
|
|
|
// The following two methods are private to disallow formatting of
|
|
|
|
// arbitrary pointers. If you want to output a pointer cast it to
|
|
|
|
// "void *" or "const void *". In particular, this forbids formatting
|
|
|
|
// of "[const] volatile char *" which is printed as bool by iostreams.
|
|
|
|
// Do not implement!
|
2014-06-30 13:19:20 +00:00
|
|
|
template <typename T>
|
2015-03-27 14:36:26 +00:00
|
|
|
MakeValue(const T *value);
|
2014-06-30 13:19:20 +00:00
|
|
|
template <typename T>
|
2015-03-27 14:36:26 +00:00
|
|
|
MakeValue(T *value);
|
2014-06-30 13:19:20 +00:00
|
|
|
|
2015-02-25 15:58:49 +00:00
|
|
|
// The following methods are private to disallow formatting of wide
|
2015-02-26 00:03:00 +00:00
|
|
|
// characters and strings into narrow strings as in
|
|
|
|
// fmt::format("{}", L"test");
|
2015-02-25 15:58:49 +00:00
|
|
|
// To fix this, use a wide format string: fmt::format(L"{}", L"test").
|
2015-03-27 14:36:26 +00:00
|
|
|
MakeValue(typename WCharHelper<wchar_t, Char>::Unsupported);
|
|
|
|
MakeValue(typename WCharHelper<wchar_t *, Char>::Unsupported);
|
|
|
|
MakeValue(typename WCharHelper<const wchar_t *, Char>::Unsupported);
|
|
|
|
MakeValue(typename WCharHelper<const std::wstring &, Char>::Unsupported);
|
|
|
|
MakeValue(typename WCharHelper<WStringRef, Char>::Unsupported);
|
2015-02-25 15:43:47 +00:00
|
|
|
|
2014-07-04 14:18:44 +00:00
|
|
|
void set_string(StringRef str) {
|
2015-06-26 14:43:54 +00:00
|
|
|
string.value = str.data();
|
2014-07-03 15:50:57 +00:00
|
|
|
string.size = str.size();
|
|
|
|
}
|
|
|
|
|
2014-07-04 14:18:44 +00:00
|
|
|
void set_string(WStringRef str) {
|
2015-06-26 14:43:54 +00:00
|
|
|
wstring.value = str.data();
|
2014-07-03 15:50:57 +00:00
|
|
|
wstring.size = str.size();
|
|
|
|
}
|
|
|
|
|
2014-07-04 14:18:44 +00:00
|
|
|
// Formats an argument of a custom type, such as a user-defined class.
|
|
|
|
template <typename T>
|
|
|
|
static void format_custom_arg(
|
2014-08-29 14:23:54 +00:00
|
|
|
void *formatter, const void *arg, void *format_str_ptr) {
|
2014-07-08 23:38:50 +00:00
|
|
|
format(*static_cast<BasicFormatter<Char>*>(formatter),
|
2014-09-24 15:07:50 +00:00
|
|
|
*static_cast<const Char**>(format_str_ptr),
|
|
|
|
*static_cast<const T*>(arg));
|
2014-07-04 14:18:44 +00:00
|
|
|
}
|
|
|
|
|
2015-02-24 16:31:56 +00:00
|
|
|
public:
|
2015-03-27 14:36:26 +00:00
|
|
|
MakeValue() {}
|
2014-09-24 14:48:45 +00:00
|
|
|
|
2015-06-26 14:43:54 +00:00
|
|
|
#define FMT_MAKE_VALUE_(Type, field, TYPE, rhs) \
|
|
|
|
MakeValue(Type value) { field = rhs; } \
|
2014-09-25 14:42:29 +00:00
|
|
|
static uint64_t type(Type) { return Arg::TYPE; }
|
2014-09-24 14:48:45 +00:00
|
|
|
|
2015-06-26 14:43:54 +00:00
|
|
|
#define FMT_MAKE_VALUE(Type, field, TYPE) \
|
|
|
|
FMT_MAKE_VALUE_(Type, field, TYPE, value)
|
|
|
|
|
2015-06-11 16:00:06 +00:00
|
|
|
FMT_MAKE_VALUE(bool, int_value, BOOL)
|
2014-09-24 15:07:50 +00:00
|
|
|
FMT_MAKE_VALUE(short, int_value, INT)
|
|
|
|
FMT_MAKE_VALUE(unsigned short, uint_value, UINT)
|
|
|
|
FMT_MAKE_VALUE(int, int_value, INT)
|
|
|
|
FMT_MAKE_VALUE(unsigned, uint_value, UINT)
|
2014-09-24 14:48:45 +00:00
|
|
|
|
2015-03-27 14:36:26 +00:00
|
|
|
MakeValue(long value) {
|
2014-07-03 15:50:57 +00:00
|
|
|
// To minimize the number of types we need to deal with, long is
|
|
|
|
// translated either to int or to long long depending on its size.
|
2015-04-05 18:27:07 +00:00
|
|
|
if (check(sizeof(long) == sizeof(int)))
|
2014-06-30 13:19:20 +00:00
|
|
|
int_value = static_cast<int>(value);
|
2014-09-23 14:59:43 +00:00
|
|
|
else
|
2014-06-30 13:19:20 +00:00
|
|
|
long_long_value = value;
|
|
|
|
}
|
2014-09-25 14:42:29 +00:00
|
|
|
static uint64_t type(long) {
|
2014-09-24 14:48:45 +00:00
|
|
|
return sizeof(long) == sizeof(int) ? Arg::INT : Arg::LONG_LONG;
|
|
|
|
}
|
|
|
|
|
2015-03-27 14:36:26 +00:00
|
|
|
MakeValue(unsigned long value) {
|
2015-04-05 18:27:07 +00:00
|
|
|
if (check(sizeof(unsigned long) == sizeof(unsigned)))
|
2014-06-30 13:19:20 +00:00
|
|
|
uint_value = static_cast<unsigned>(value);
|
2014-09-23 14:59:43 +00:00
|
|
|
else
|
2014-06-30 13:19:20 +00:00
|
|
|
ulong_long_value = value;
|
|
|
|
}
|
2014-09-25 14:42:29 +00:00
|
|
|
static uint64_t type(unsigned long) {
|
2014-09-24 14:48:45 +00:00
|
|
|
return sizeof(unsigned long) == sizeof(unsigned) ?
|
|
|
|
Arg::UINT : Arg::ULONG_LONG;
|
|
|
|
}
|
|
|
|
|
2014-09-24 15:07:50 +00:00
|
|
|
FMT_MAKE_VALUE(LongLong, long_long_value, LONG_LONG)
|
|
|
|
FMT_MAKE_VALUE(ULongLong, ulong_long_value, ULONG_LONG)
|
|
|
|
FMT_MAKE_VALUE(float, double_value, DOUBLE)
|
|
|
|
FMT_MAKE_VALUE(double, double_value, DOUBLE)
|
|
|
|
FMT_MAKE_VALUE(long double, long_double_value, LONG_DOUBLE)
|
|
|
|
FMT_MAKE_VALUE(signed char, int_value, CHAR)
|
|
|
|
FMT_MAKE_VALUE(unsigned char, int_value, CHAR)
|
|
|
|
FMT_MAKE_VALUE(char, int_value, CHAR)
|
2014-09-24 14:48:45 +00:00
|
|
|
|
2015-03-27 14:36:26 +00:00
|
|
|
MakeValue(typename WCharHelper<wchar_t, Char>::Supported value) {
|
2015-02-26 00:03:00 +00:00
|
|
|
int_value = value;
|
2014-06-30 13:19:20 +00:00
|
|
|
}
|
2014-09-25 14:42:29 +00:00
|
|
|
static uint64_t type(wchar_t) { return Arg::CHAR; }
|
2014-06-30 13:19:20 +00:00
|
|
|
|
2014-09-24 15:07:50 +00:00
|
|
|
#define FMT_MAKE_STR_VALUE(Type, TYPE) \
|
2015-03-27 14:36:26 +00:00
|
|
|
MakeValue(Type value) { set_string(value); } \
|
2014-09-25 14:42:29 +00:00
|
|
|
static uint64_t type(Type) { return Arg::TYPE; }
|
2014-06-30 13:19:20 +00:00
|
|
|
|
2014-09-25 14:10:44 +00:00
|
|
|
FMT_MAKE_VALUE(char *, string.value, CSTRING)
|
|
|
|
FMT_MAKE_VALUE(const char *, string.value, CSTRING)
|
2014-09-30 15:15:56 +00:00
|
|
|
FMT_MAKE_VALUE(const signed char *, sstring.value, CSTRING)
|
|
|
|
FMT_MAKE_VALUE(const unsigned char *, ustring.value, CSTRING)
|
2014-09-24 15:07:50 +00:00
|
|
|
FMT_MAKE_STR_VALUE(const std::string &, STRING)
|
|
|
|
FMT_MAKE_STR_VALUE(StringRef, STRING)
|
2015-06-26 14:43:54 +00:00
|
|
|
FMT_MAKE_VALUE_(CStringRef, string.value, CSTRING, value.c_str())
|
2014-06-30 13:19:20 +00:00
|
|
|
|
2015-02-25 15:58:49 +00:00
|
|
|
#define FMT_MAKE_WSTR_VALUE(Type, TYPE) \
|
2015-03-27 14:36:26 +00:00
|
|
|
MakeValue(typename WCharHelper<Type, Char>::Supported value) { \
|
2015-02-25 15:58:49 +00:00
|
|
|
set_string(value); \
|
|
|
|
} \
|
|
|
|
static uint64_t type(Type) { return Arg::TYPE; }
|
2015-02-25 15:43:47 +00:00
|
|
|
|
2015-02-25 15:58:49 +00:00
|
|
|
FMT_MAKE_WSTR_VALUE(wchar_t *, WSTRING)
|
|
|
|
FMT_MAKE_WSTR_VALUE(const wchar_t *, WSTRING)
|
|
|
|
FMT_MAKE_WSTR_VALUE(const std::wstring &, WSTRING)
|
|
|
|
FMT_MAKE_WSTR_VALUE(WStringRef, WSTRING)
|
2014-09-24 14:48:45 +00:00
|
|
|
|
2014-09-24 15:07:50 +00:00
|
|
|
FMT_MAKE_VALUE(void *, pointer, POINTER)
|
|
|
|
FMT_MAKE_VALUE(const void *, pointer, POINTER)
|
2014-06-30 13:19:20 +00:00
|
|
|
|
|
|
|
template <typename T>
|
2015-03-27 14:36:26 +00:00
|
|
|
MakeValue(const T &value,
|
|
|
|
typename EnableIf<!IsConvertibleToInt<T>::value, int>::type = 0) {
|
2014-06-30 13:19:20 +00:00
|
|
|
custom.value = &value;
|
2014-07-04 14:18:44 +00:00
|
|
|
custom.format = &format_custom_arg<T>;
|
2014-06-30 13:19:20 +00:00
|
|
|
}
|
2015-03-10 14:53:46 +00:00
|
|
|
|
2014-09-24 14:48:45 +00:00
|
|
|
template <typename T>
|
2015-03-27 14:36:26 +00:00
|
|
|
MakeValue(const T &value,
|
|
|
|
typename EnableIf<IsConvertibleToInt<T>::value, int>::type = 0) {
|
2015-03-10 14:53:46 +00:00
|
|
|
int_value = value;
|
|
|
|
}
|
|
|
|
|
|
|
|
template <typename T>
|
|
|
|
static uint64_t type(const T &) {
|
|
|
|
return IsConvertibleToInt<T>::value ? Arg::INT : Arg::CUSTOM;
|
|
|
|
}
|
2015-06-10 01:32:59 +00:00
|
|
|
|
2015-06-10 15:49:22 +00:00
|
|
|
// Additional template param `Char_` is needed here because make_type always
|
|
|
|
// uses MakeValue<char>.
|
2015-06-10 01:32:59 +00:00
|
|
|
template <typename Char_>
|
|
|
|
MakeValue(const NamedArg<Char_> &value) { pointer = &value; }
|
|
|
|
|
|
|
|
template <typename Char_>
|
|
|
|
static uint64_t type(const NamedArg<Char_> &) { return Arg::NAMED_ARG; }
|
|
|
|
};
|
|
|
|
|
|
|
|
template <typename Char>
|
|
|
|
struct NamedArg : Arg {
|
|
|
|
BasicStringRef<Char> name;
|
|
|
|
|
|
|
|
template <typename T>
|
2015-08-04 10:52:44 +00:00
|
|
|
NamedArg(BasicStringRef<Char> argname, const T &value)
|
2015-08-17 11:59:45 +00:00
|
|
|
: Arg(MakeValue<Char>(value)), name(argname) {
|
2015-06-10 01:32:59 +00:00
|
|
|
type = static_cast<internal::Arg::Type>(MakeValue<Char>::type(value));
|
|
|
|
}
|
2014-06-30 13:19:20 +00:00
|
|
|
};
|
|
|
|
|
2014-07-14 13:55:29 +00:00
|
|
|
#define FMT_DISPATCH(call) static_cast<Impl*>(this)->call
|
|
|
|
|
|
|
|
// An argument visitor.
|
|
|
|
// To use ArgVisitor define a subclass that implements some or all of the
|
|
|
|
// visit methods with the same signatures as the methods in ArgVisitor,
|
|
|
|
// for example, visit_int(int).
|
|
|
|
// Specify the subclass name as the Impl template parameter. Then calling
|
|
|
|
// ArgVisitor::visit for some argument will dispatch to a visit method
|
|
|
|
// specific to the argument type. For example, if the argument type is
|
|
|
|
// double then visit_double(double) method of a subclass will be called.
|
|
|
|
// If the subclass doesn't contain a method with this signature, then
|
|
|
|
// a corresponding method of ArgVisitor will be called.
|
|
|
|
//
|
|
|
|
// Example:
|
|
|
|
// class MyArgVisitor : public ArgVisitor<MyArgVisitor, void> {
|
|
|
|
// public:
|
|
|
|
// void visit_int(int value) { print("{}", value); }
|
|
|
|
// void visit_double(double value) { print("{}", value ); }
|
|
|
|
// };
|
|
|
|
//
|
|
|
|
// ArgVisitor uses the curiously recurring template pattern:
|
|
|
|
// http://en.wikipedia.org/wiki/Curiously_recurring_template_pattern
|
|
|
|
template <typename Impl, typename Result>
|
|
|
|
class ArgVisitor {
|
|
|
|
public:
|
2015-03-26 15:55:20 +00:00
|
|
|
void report_unhandled_arg() {}
|
|
|
|
|
|
|
|
Result visit_unhandled_arg() {
|
|
|
|
FMT_DISPATCH(report_unhandled_arg());
|
|
|
|
return Result();
|
|
|
|
}
|
2014-07-14 13:55:29 +00:00
|
|
|
|
|
|
|
Result visit_int(int value) {
|
2014-07-16 14:55:31 +00:00
|
|
|
return FMT_DISPATCH(visit_any_int(value));
|
2014-07-14 13:55:29 +00:00
|
|
|
}
|
|
|
|
Result visit_long_long(LongLong value) {
|
2014-07-16 14:27:54 +00:00
|
|
|
return FMT_DISPATCH(visit_any_int(value));
|
2014-07-14 13:55:29 +00:00
|
|
|
}
|
|
|
|
Result visit_uint(unsigned value) {
|
2014-07-16 14:55:31 +00:00
|
|
|
return FMT_DISPATCH(visit_any_int(value));
|
2014-07-14 13:55:29 +00:00
|
|
|
}
|
|
|
|
Result visit_ulong_long(ULongLong value) {
|
2014-07-16 14:27:54 +00:00
|
|
|
return FMT_DISPATCH(visit_any_int(value));
|
2014-07-14 13:55:29 +00:00
|
|
|
}
|
2015-06-11 16:00:06 +00:00
|
|
|
Result visit_bool(bool value) {
|
|
|
|
return FMT_DISPATCH(visit_any_int(value));
|
|
|
|
}
|
2014-07-30 15:39:07 +00:00
|
|
|
Result visit_char(int value) {
|
|
|
|
return FMT_DISPATCH(visit_any_int(value));
|
|
|
|
}
|
2014-07-16 14:27:54 +00:00
|
|
|
template <typename T>
|
|
|
|
Result visit_any_int(T) {
|
2014-07-14 13:55:29 +00:00
|
|
|
return FMT_DISPATCH(visit_unhandled_arg());
|
|
|
|
}
|
2014-07-16 14:27:54 +00:00
|
|
|
|
|
|
|
Result visit_double(double value) {
|
|
|
|
return FMT_DISPATCH(visit_any_double(value));
|
|
|
|
}
|
|
|
|
Result visit_long_double(long double value) {
|
|
|
|
return FMT_DISPATCH(visit_any_double(value));
|
|
|
|
}
|
|
|
|
template <typename T>
|
|
|
|
Result visit_any_double(T) {
|
2014-07-14 13:55:29 +00:00
|
|
|
return FMT_DISPATCH(visit_unhandled_arg());
|
|
|
|
}
|
2014-07-16 14:27:54 +00:00
|
|
|
|
2014-07-14 15:04:17 +00:00
|
|
|
Result visit_string(Arg::StringValue<char>) {
|
2014-07-14 13:55:29 +00:00
|
|
|
return FMT_DISPATCH(visit_unhandled_arg());
|
|
|
|
}
|
2014-07-14 15:04:17 +00:00
|
|
|
Result visit_wstring(Arg::StringValue<wchar_t>) {
|
2014-07-14 13:55:29 +00:00
|
|
|
return FMT_DISPATCH(visit_unhandled_arg());
|
|
|
|
}
|
|
|
|
Result visit_pointer(const void *) {
|
|
|
|
return FMT_DISPATCH(visit_unhandled_arg());
|
|
|
|
}
|
|
|
|
Result visit_custom(Arg::CustomValue) {
|
|
|
|
return FMT_DISPATCH(visit_unhandled_arg());
|
|
|
|
}
|
|
|
|
|
|
|
|
Result visit(const Arg &arg) {
|
|
|
|
switch (arg.type) {
|
|
|
|
default:
|
2015-06-22 15:17:23 +00:00
|
|
|
FMT_ASSERT(false, "invalid argument type");
|
2015-02-09 15:37:26 +00:00
|
|
|
return Result();
|
2014-07-14 13:55:29 +00:00
|
|
|
case Arg::INT:
|
|
|
|
return FMT_DISPATCH(visit_int(arg.int_value));
|
|
|
|
case Arg::UINT:
|
|
|
|
return FMT_DISPATCH(visit_uint(arg.uint_value));
|
|
|
|
case Arg::LONG_LONG:
|
|
|
|
return FMT_DISPATCH(visit_long_long(arg.long_long_value));
|
|
|
|
case Arg::ULONG_LONG:
|
|
|
|
return FMT_DISPATCH(visit_ulong_long(arg.ulong_long_value));
|
2015-06-11 16:00:06 +00:00
|
|
|
case Arg::BOOL:
|
2015-07-08 14:52:03 +00:00
|
|
|
return FMT_DISPATCH(visit_bool(arg.int_value != 0));
|
2015-06-11 16:00:06 +00:00
|
|
|
case Arg::CHAR:
|
|
|
|
return FMT_DISPATCH(visit_char(arg.int_value));
|
2014-07-14 13:55:29 +00:00
|
|
|
case Arg::DOUBLE:
|
|
|
|
return FMT_DISPATCH(visit_double(arg.double_value));
|
|
|
|
case Arg::LONG_DOUBLE:
|
|
|
|
return FMT_DISPATCH(visit_long_double(arg.long_double_value));
|
2014-09-25 14:10:44 +00:00
|
|
|
case Arg::CSTRING: {
|
2015-03-25 13:48:21 +00:00
|
|
|
Arg::StringValue<char> str = arg.string;
|
2014-09-25 14:10:44 +00:00
|
|
|
str.size = 0;
|
|
|
|
return FMT_DISPATCH(visit_string(str));
|
|
|
|
}
|
2014-07-14 13:55:29 +00:00
|
|
|
case Arg::STRING:
|
|
|
|
return FMT_DISPATCH(visit_string(arg.string));
|
|
|
|
case Arg::WSTRING:
|
|
|
|
return FMT_DISPATCH(visit_wstring(arg.wstring));
|
|
|
|
case Arg::POINTER:
|
2014-09-23 15:21:58 +00:00
|
|
|
return FMT_DISPATCH(visit_pointer(arg.pointer));
|
2014-07-14 13:55:29 +00:00
|
|
|
case Arg::CUSTOM:
|
|
|
|
return FMT_DISPATCH(visit_custom(arg.custom));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2014-07-02 04:01:15 +00:00
|
|
|
class RuntimeError : public std::runtime_error {
|
|
|
|
protected:
|
|
|
|
RuntimeError() : std::runtime_error("") {}
|
2014-06-30 21:26:29 +00:00
|
|
|
};
|
2014-07-14 15:47:03 +00:00
|
|
|
|
2015-06-16 14:36:32 +00:00
|
|
|
template <typename Impl, typename Char>
|
|
|
|
class BasicArgFormatter;
|
|
|
|
|
2014-07-14 15:47:03 +00:00
|
|
|
template <typename Char>
|
2015-06-16 14:36:32 +00:00
|
|
|
class PrintfArgFormatter;
|
2015-06-10 15:49:22 +00:00
|
|
|
|
|
|
|
template <typename Char>
|
|
|
|
class ArgMap;
|
2014-06-06 13:38:37 +00:00
|
|
|
} // namespace internal
|
|
|
|
|
2015-03-24 15:55:40 +00:00
|
|
|
/** An argument list. */
|
2014-06-30 21:26:29 +00:00
|
|
|
class ArgList {
|
2014-04-30 13:55:21 +00:00
|
|
|
private:
|
2015-03-24 15:55:40 +00:00
|
|
|
// To reduce compiled code size per formatting function call, types of first
|
|
|
|
// MAX_PACKED_ARGS arguments are passed in the types_ field.
|
|
|
|
uint64_t types_;
|
2015-04-20 17:02:41 +00:00
|
|
|
union {
|
|
|
|
// If the number of arguments is less than MAX_PACKED_ARGS, the argument
|
|
|
|
// values are stored in values_, otherwise they are stored in args_.
|
|
|
|
// This is done to reduce compiled code size as storing larger objects
|
|
|
|
// may require more code (at least on x86-64) even if the same amount of
|
|
|
|
// data is actually copied to stack. It saves ~10% on the bloat test.
|
|
|
|
const internal::Value *values_;
|
|
|
|
const internal::Arg *args_;
|
|
|
|
};
|
2013-09-05 05:03:37 +00:00
|
|
|
|
2015-03-24 15:55:40 +00:00
|
|
|
internal::Arg::Type type(unsigned index) const {
|
|
|
|
unsigned shift = index * 4;
|
|
|
|
uint64_t mask = 0xf;
|
|
|
|
return static_cast<internal::Arg::Type>(
|
|
|
|
(types_ & (mask << shift)) >> shift);
|
|
|
|
}
|
|
|
|
|
2015-06-10 15:49:22 +00:00
|
|
|
template <typename Char>
|
|
|
|
friend class internal::ArgMap;
|
|
|
|
|
2014-07-02 04:01:15 +00:00
|
|
|
public:
|
2015-03-24 15:55:40 +00:00
|
|
|
// Maximum number of arguments with packed types.
|
|
|
|
enum { MAX_PACKED_ARGS = 16 };
|
|
|
|
|
|
|
|
ArgList() : types_(0) {}
|
2015-04-20 17:02:41 +00:00
|
|
|
|
|
|
|
ArgList(ULongLong types, const internal::Value *values)
|
|
|
|
: types_(types), values_(values) {}
|
2015-03-25 13:48:21 +00:00
|
|
|
ArgList(ULongLong types, const internal::Arg *args)
|
|
|
|
: types_(types), args_(args) {}
|
2014-06-30 21:26:29 +00:00
|
|
|
|
2015-03-24 15:55:40 +00:00
|
|
|
/** Returns the argument at specified index. */
|
2014-09-23 14:59:43 +00:00
|
|
|
internal::Arg operator[](unsigned index) const {
|
2014-09-23 15:11:03 +00:00
|
|
|
using internal::Arg;
|
2014-09-25 16:31:36 +00:00
|
|
|
Arg arg;
|
2015-04-20 17:02:41 +00:00
|
|
|
bool use_values = type(MAX_PACKED_ARGS - 1) == Arg::NONE;
|
2015-03-25 13:48:21 +00:00
|
|
|
if (index < MAX_PACKED_ARGS) {
|
|
|
|
Arg::Type arg_type = type(index);
|
2015-04-20 17:02:41 +00:00
|
|
|
internal::Value &val = arg;
|
2015-03-25 13:48:21 +00:00
|
|
|
if (arg_type != Arg::NONE)
|
2015-04-20 17:02:41 +00:00
|
|
|
val = use_values ? values_[index] : args_[index];
|
2015-03-25 13:48:21 +00:00
|
|
|
arg.type = arg_type;
|
|
|
|
return arg;
|
|
|
|
}
|
2015-04-20 17:02:41 +00:00
|
|
|
if (use_values) {
|
|
|
|
// The index is greater than the number of arguments that can be stored
|
|
|
|
// in values, so return a "none" argument.
|
2015-03-25 13:48:21 +00:00
|
|
|
arg.type = Arg::NONE;
|
|
|
|
return arg;
|
2015-03-24 15:55:40 +00:00
|
|
|
}
|
2015-03-25 13:48:21 +00:00
|
|
|
for (unsigned i = MAX_PACKED_ARGS; i <= index; ++i) {
|
|
|
|
if (args_[i].type == Arg::NONE)
|
|
|
|
return args_[i];
|
2014-09-23 14:59:43 +00:00
|
|
|
}
|
2015-03-25 13:48:21 +00:00
|
|
|
return args_[index];
|
2014-06-30 21:26:29 +00:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2015-06-10 15:49:22 +00:00
|
|
|
struct FormatSpec;
|
|
|
|
|
|
|
|
namespace internal {
|
|
|
|
|
2015-06-10 01:32:59 +00:00
|
|
|
template <typename Char>
|
2015-06-10 15:49:22 +00:00
|
|
|
class ArgMap {
|
|
|
|
private:
|
2015-06-10 01:32:59 +00:00
|
|
|
typedef std::map<fmt::BasicStringRef<Char>, internal::Arg> MapType;
|
|
|
|
typedef typename MapType::value_type Pair;
|
|
|
|
|
2015-06-10 15:49:22 +00:00
|
|
|
MapType map_;
|
|
|
|
|
|
|
|
public:
|
2015-06-10 01:32:59 +00:00
|
|
|
void init(const ArgList &args);
|
|
|
|
|
|
|
|
const internal::Arg* find(const fmt::BasicStringRef<Char> &name) const {
|
|
|
|
typename MapType::const_iterator it = map_.find(name);
|
2015-06-11 14:19:00 +00:00
|
|
|
return it != map_.end() ? &it->second : 0;
|
2015-06-10 01:32:59 +00:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2014-07-16 15:38:15 +00:00
|
|
|
class FormatterBase {
|
2015-06-11 14:19:00 +00:00
|
|
|
private:
|
2014-07-08 23:20:33 +00:00
|
|
|
ArgList args_;
|
|
|
|
int next_arg_index_;
|
|
|
|
|
2014-08-29 14:45:55 +00:00
|
|
|
// Returns the argument with specified index.
|
2014-09-23 14:59:43 +00:00
|
|
|
Arg do_get_arg(unsigned arg_index, const char *&error);
|
2014-08-29 14:45:55 +00:00
|
|
|
|
|
|
|
protected:
|
2015-06-11 14:19:00 +00:00
|
|
|
const ArgList &args() const { return args_; }
|
|
|
|
|
2015-07-28 15:09:29 +00:00
|
|
|
explicit FormatterBase(const ArgList &args) {
|
2014-08-29 14:45:55 +00:00
|
|
|
args_ = args;
|
|
|
|
next_arg_index_ = 0;
|
|
|
|
}
|
|
|
|
|
2014-08-28 15:05:47 +00:00
|
|
|
// Returns the next argument.
|
2014-09-23 14:59:43 +00:00
|
|
|
Arg next_arg(const char *&error);
|
2014-07-08 23:20:33 +00:00
|
|
|
|
2014-08-29 14:45:55 +00:00
|
|
|
// Checks if manual indexing is used and returns the argument with
|
|
|
|
// specified index.
|
2014-09-23 14:59:43 +00:00
|
|
|
Arg get_arg(unsigned arg_index, const char *&error);
|
2014-07-08 23:20:33 +00:00
|
|
|
|
2015-06-10 01:32:59 +00:00
|
|
|
bool check_no_auto_index(const char *&error);
|
|
|
|
|
2014-07-24 15:53:27 +00:00
|
|
|
template <typename Char>
|
|
|
|
void write(BasicWriter<Char> &w, const Char *start, const Char *end) {
|
|
|
|
if (start != end)
|
|
|
|
w << BasicStringRef<Char>(start, end - start);
|
|
|
|
}
|
2014-07-08 23:20:33 +00:00
|
|
|
};
|
|
|
|
|
2014-07-16 14:59:45 +00:00
|
|
|
// A printf formatter.
|
2014-06-30 21:26:29 +00:00
|
|
|
template <typename Char>
|
2014-07-16 15:38:15 +00:00
|
|
|
class PrintfFormatter : private FormatterBase {
|
2014-06-30 21:26:29 +00:00
|
|
|
private:
|
2014-07-28 15:41:50 +00:00
|
|
|
void parse_flags(FormatSpec &spec, const Char *&s);
|
2014-06-30 21:26:29 +00:00
|
|
|
|
2014-08-28 15:05:47 +00:00
|
|
|
// Returns the argument with specified index or, if arg_index is equal
|
|
|
|
// to the maximum unsigned value, the next argument.
|
2014-09-23 14:59:43 +00:00
|
|
|
Arg get_arg(const Char *s,
|
2014-09-12 20:42:22 +00:00
|
|
|
unsigned arg_index = (std::numeric_limits<unsigned>::max)());
|
2014-08-28 15:05:47 +00:00
|
|
|
|
2014-08-28 14:48:55 +00:00
|
|
|
// Parses argument index, flags and width and returns the argument index.
|
2014-07-28 15:41:50 +00:00
|
|
|
unsigned parse_header(const Char *&s, FormatSpec &spec);
|
2014-06-30 21:26:29 +00:00
|
|
|
|
|
|
|
public:
|
2015-07-28 15:09:29 +00:00
|
|
|
explicit PrintfFormatter(const ArgList &args) : FormatterBase(args) {}
|
|
|
|
void format(BasicWriter<Char> &writer, BasicCStringRef<Char> format_str);
|
2012-12-11 18:27:13 +00:00
|
|
|
};
|
2014-06-30 21:26:29 +00:00
|
|
|
} // namespace internal
|
2012-12-11 18:27:13 +00:00
|
|
|
|
2014-07-16 15:38:15 +00:00
|
|
|
// A formatter.
|
|
|
|
template <typename Char>
|
|
|
|
class BasicFormatter : private internal::FormatterBase {
|
2014-09-21 15:08:52 +00:00
|
|
|
private:
|
2014-07-16 15:38:15 +00:00
|
|
|
BasicWriter<Char> &writer_;
|
2015-06-10 15:49:22 +00:00
|
|
|
internal::ArgMap<Char> map_;
|
2014-12-03 14:16:52 +00:00
|
|
|
|
|
|
|
FMT_DISALLOW_COPY_AND_ASSIGN(BasicFormatter);
|
2014-07-16 15:38:15 +00:00
|
|
|
|
2015-06-10 01:32:59 +00:00
|
|
|
using FormatterBase::get_arg;
|
|
|
|
|
|
|
|
// Checks if manual indexing is used and returns the argument with
|
|
|
|
// specified name.
|
2015-06-11 14:19:00 +00:00
|
|
|
internal::Arg get_arg(BasicStringRef<Char> arg_name, const char *&error);
|
2015-06-10 01:32:59 +00:00
|
|
|
|
2014-08-28 13:42:59 +00:00
|
|
|
// Parses argument index and returns corresponding argument.
|
2014-09-23 14:59:43 +00:00
|
|
|
internal::Arg parse_arg_index(const Char *&s);
|
2014-07-16 15:38:15 +00:00
|
|
|
|
2015-06-10 01:32:59 +00:00
|
|
|
// Parses argument name and returns corresponding argument.
|
|
|
|
internal::Arg parse_arg_name(const Char *&s);
|
|
|
|
|
2014-09-21 15:08:52 +00:00
|
|
|
public:
|
2015-07-28 15:09:29 +00:00
|
|
|
BasicFormatter(const ArgList &args, BasicWriter<Char> &w)
|
|
|
|
: FormatterBase(args), writer_(w) {}
|
2014-07-16 15:38:15 +00:00
|
|
|
|
|
|
|
BasicWriter<Char> &writer() { return writer_; }
|
|
|
|
|
2015-07-28 15:09:29 +00:00
|
|
|
void format(BasicCStringRef<Char> format_str);
|
2014-07-16 15:38:15 +00:00
|
|
|
|
2014-08-29 14:23:54 +00:00
|
|
|
const Char *format(const Char *&format_str, const internal::Arg &arg);
|
2014-07-16 15:38:15 +00:00
|
|
|
};
|
|
|
|
|
2012-12-22 22:05:56 +00:00
|
|
|
enum Alignment {
|
|
|
|
ALIGN_DEFAULT, ALIGN_LEFT, ALIGN_RIGHT, ALIGN_CENTER, ALIGN_NUMERIC
|
|
|
|
};
|
|
|
|
|
2013-01-08 17:56:05 +00:00
|
|
|
// Flags.
|
2014-07-25 15:24:27 +00:00
|
|
|
enum {
|
|
|
|
SIGN_FLAG = 1, PLUS_FLAG = 2, MINUS_FLAG = 4, HASH_FLAG = 8,
|
|
|
|
CHAR_FLAG = 0x10 // Argument has char type - used in error reporting.
|
|
|
|
};
|
2013-01-08 17:56:05 +00:00
|
|
|
|
2014-01-01 17:06:25 +00:00
|
|
|
// An empty format specifier.
|
|
|
|
struct EmptySpec {};
|
2013-01-08 17:56:05 +00:00
|
|
|
|
2014-01-01 17:06:25 +00:00
|
|
|
// A type specifier.
|
2013-01-08 17:56:05 +00:00
|
|
|
template <char TYPE>
|
2014-01-01 17:06:25 +00:00
|
|
|
struct TypeSpec : EmptySpec {
|
2013-01-08 17:56:05 +00:00
|
|
|
Alignment align() const { return ALIGN_DEFAULT; }
|
|
|
|
unsigned width() const { return 0; }
|
2014-06-20 14:34:02 +00:00
|
|
|
int precision() const { return -1; }
|
2014-07-25 15:29:06 +00:00
|
|
|
bool flag(unsigned) const { return false; }
|
2013-01-08 17:56:05 +00:00
|
|
|
char type() const { return TYPE; }
|
|
|
|
char fill() const { return ' '; }
|
|
|
|
};
|
|
|
|
|
2014-01-01 17:06:25 +00:00
|
|
|
// A width specifier.
|
2013-01-08 17:56:05 +00:00
|
|
|
struct WidthSpec {
|
|
|
|
unsigned width_;
|
2013-09-08 20:07:04 +00:00
|
|
|
// Fill is always wchar_t and cast to char if necessary to avoid having
|
|
|
|
// two specialization of WidthSpec and its subclasses.
|
|
|
|
wchar_t fill_;
|
2013-01-08 17:56:05 +00:00
|
|
|
|
2013-09-08 20:07:04 +00:00
|
|
|
WidthSpec(unsigned width, wchar_t fill) : width_(width), fill_(fill) {}
|
2013-01-08 17:56:05 +00:00
|
|
|
|
|
|
|
unsigned width() const { return width_; }
|
2013-09-08 20:07:04 +00:00
|
|
|
wchar_t fill() const { return fill_; }
|
2013-01-08 17:56:05 +00:00
|
|
|
};
|
|
|
|
|
2014-01-01 17:06:25 +00:00
|
|
|
// An alignment specifier.
|
2013-01-08 17:56:05 +00:00
|
|
|
struct AlignSpec : WidthSpec {
|
|
|
|
Alignment align_;
|
|
|
|
|
2014-01-01 17:06:25 +00:00
|
|
|
AlignSpec(unsigned width, wchar_t fill, Alignment align = ALIGN_DEFAULT)
|
|
|
|
: WidthSpec(width, fill), align_(align) {}
|
2013-01-08 17:56:05 +00:00
|
|
|
|
|
|
|
Alignment align() const { return align_; }
|
2014-06-20 14:34:02 +00:00
|
|
|
|
|
|
|
int precision() const { return -1; }
|
2013-01-08 17:56:05 +00:00
|
|
|
};
|
|
|
|
|
2014-01-01 17:06:25 +00:00
|
|
|
// An alignment and type specifier.
|
2014-01-28 20:47:37 +00:00
|
|
|
template <char TYPE>
|
|
|
|
struct AlignTypeSpec : AlignSpec {
|
|
|
|
AlignTypeSpec(unsigned width, wchar_t fill) : AlignSpec(width, fill) {}
|
2013-01-08 17:56:05 +00:00
|
|
|
|
2014-07-25 15:29:06 +00:00
|
|
|
bool flag(unsigned) const { return false; }
|
2013-01-08 17:56:05 +00:00
|
|
|
char type() const { return TYPE; }
|
|
|
|
};
|
|
|
|
|
2014-01-01 17:06:25 +00:00
|
|
|
// A full format specifier.
|
2014-01-28 20:47:37 +00:00
|
|
|
struct FormatSpec : AlignSpec {
|
2013-01-08 17:56:05 +00:00
|
|
|
unsigned flags_;
|
2014-06-20 14:34:02 +00:00
|
|
|
int precision_;
|
2013-01-08 17:56:05 +00:00
|
|
|
char type_;
|
2012-12-21 17:12:04 +00:00
|
|
|
|
2014-06-20 14:34:02 +00:00
|
|
|
FormatSpec(
|
|
|
|
unsigned width = 0, char type = 0, wchar_t fill = ' ')
|
|
|
|
: AlignSpec(width, fill), flags_(0), precision_(-1), type_(type) {}
|
2013-01-08 17:56:05 +00:00
|
|
|
|
2014-07-25 15:29:06 +00:00
|
|
|
bool flag(unsigned f) const { return (flags_ & f) != 0; }
|
2014-06-20 14:34:02 +00:00
|
|
|
int precision() const { return precision_; }
|
2013-01-08 17:56:05 +00:00
|
|
|
char type() const { return type_; }
|
|
|
|
};
|
|
|
|
|
2014-01-01 17:20:16 +00:00
|
|
|
// An integer format specifier.
|
2014-01-28 20:47:37 +00:00
|
|
|
template <typename T, typename SpecT = TypeSpec<0>, typename Char = char>
|
2014-01-01 17:20:16 +00:00
|
|
|
class IntFormatSpec : public SpecT {
|
2013-01-08 17:56:05 +00:00
|
|
|
private:
|
|
|
|
T value_;
|
|
|
|
|
|
|
|
public:
|
2014-12-10 15:24:05 +00:00
|
|
|
IntFormatSpec(T val, const SpecT &spec = SpecT())
|
|
|
|
: SpecT(spec), value_(val) {}
|
2013-01-08 17:56:05 +00:00
|
|
|
|
|
|
|
T value() const { return value_; }
|
2012-12-21 04:10:55 +00:00
|
|
|
};
|
|
|
|
|
2014-01-01 17:22:55 +00:00
|
|
|
// A string format specifier.
|
2015-06-03 15:39:43 +00:00
|
|
|
template <typename Char>
|
2014-01-28 20:47:37 +00:00
|
|
|
class StrFormatSpec : public AlignSpec {
|
2013-12-31 17:43:32 +00:00
|
|
|
private:
|
2015-06-03 15:39:43 +00:00
|
|
|
const Char *str_;
|
2013-12-31 17:43:32 +00:00
|
|
|
|
|
|
|
public:
|
2015-06-03 15:39:43 +00:00
|
|
|
template <typename FillChar>
|
|
|
|
StrFormatSpec(const Char *str, unsigned width, FillChar fill)
|
|
|
|
: AlignSpec(width, fill), str_(str) {
|
|
|
|
internal::CharTraits<Char>::convert(FillChar());
|
|
|
|
}
|
2013-12-31 17:43:32 +00:00
|
|
|
|
2015-06-03 15:39:43 +00:00
|
|
|
const Char *str() const { return str_; }
|
2013-12-31 17:43:32 +00:00
|
|
|
};
|
|
|
|
|
2013-10-24 03:04:32 +00:00
|
|
|
/**
|
2014-01-01 17:20:16 +00:00
|
|
|
Returns an integer format specifier to format the value in base 2.
|
2013-10-24 03:04:32 +00:00
|
|
|
*/
|
2014-01-01 17:20:16 +00:00
|
|
|
IntFormatSpec<int, TypeSpec<'b'> > bin(int value);
|
2013-10-24 03:04:32 +00:00
|
|
|
|
2013-01-22 19:06:56 +00:00
|
|
|
/**
|
2014-01-01 17:20:16 +00:00
|
|
|
Returns an integer format specifier to format the value in base 8.
|
2013-09-05 03:44:13 +00:00
|
|
|
*/
|
2014-01-01 17:20:16 +00:00
|
|
|
IntFormatSpec<int, TypeSpec<'o'> > oct(int value);
|
2013-01-22 19:06:56 +00:00
|
|
|
|
|
|
|
/**
|
2014-01-01 17:20:16 +00:00
|
|
|
Returns an integer format specifier to format the value in base 16 using
|
2013-01-22 19:06:56 +00:00
|
|
|
lower-case letters for the digits above 9.
|
|
|
|
*/
|
2014-01-01 17:20:16 +00:00
|
|
|
IntFormatSpec<int, TypeSpec<'x'> > hex(int value);
|
2013-01-22 19:06:56 +00:00
|
|
|
|
|
|
|
/**
|
2014-01-01 17:20:16 +00:00
|
|
|
Returns an integer formatter format specifier to format in base 16 using
|
2013-01-22 19:06:56 +00:00
|
|
|
upper-case letters for the digits above 9.
|
|
|
|
*/
|
2014-01-01 17:20:16 +00:00
|
|
|
IntFormatSpec<int, TypeSpec<'X'> > hexu(int value);
|
2013-01-22 19:06:56 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
\rst
|
2014-01-01 17:20:16 +00:00
|
|
|
Returns an integer format specifier to pad the formatted argument with the
|
|
|
|
fill character to the specified width using the default (right) numeric
|
|
|
|
alignment.
|
2013-01-22 19:06:56 +00:00
|
|
|
|
|
|
|
**Example**::
|
|
|
|
|
2014-10-01 15:32:01 +00:00
|
|
|
MemoryWriter out;
|
2014-05-13 14:39:18 +00:00
|
|
|
out << pad(hex(0xcafe), 8, '0');
|
|
|
|
// out.str() == "0000cafe"
|
2013-01-22 19:06:56 +00:00
|
|
|
|
|
|
|
\endrst
|
|
|
|
*/
|
2014-01-28 20:47:37 +00:00
|
|
|
template <char TYPE_CODE, typename Char>
|
|
|
|
IntFormatSpec<int, AlignTypeSpec<TYPE_CODE>, Char> pad(
|
2014-01-08 16:17:38 +00:00
|
|
|
int value, unsigned width, Char fill = ' ');
|
2013-01-22 19:06:56 +00:00
|
|
|
|
2014-04-24 00:33:50 +00:00
|
|
|
#define FMT_DEFINE_INT_FORMATTERS(TYPE) \
|
2014-01-01 17:20:16 +00:00
|
|
|
inline IntFormatSpec<TYPE, TypeSpec<'b'> > bin(TYPE value) { \
|
|
|
|
return IntFormatSpec<TYPE, TypeSpec<'b'> >(value, TypeSpec<'b'>()); \
|
2013-10-24 03:04:32 +00:00
|
|
|
} \
|
2013-11-14 16:45:20 +00:00
|
|
|
\
|
2014-01-01 17:20:16 +00:00
|
|
|
inline IntFormatSpec<TYPE, TypeSpec<'o'> > oct(TYPE value) { \
|
|
|
|
return IntFormatSpec<TYPE, TypeSpec<'o'> >(value, TypeSpec<'o'>()); \
|
2013-01-13 17:29:37 +00:00
|
|
|
} \
|
|
|
|
\
|
2014-01-01 17:20:16 +00:00
|
|
|
inline IntFormatSpec<TYPE, TypeSpec<'x'> > hex(TYPE value) { \
|
|
|
|
return IntFormatSpec<TYPE, TypeSpec<'x'> >(value, TypeSpec<'x'>()); \
|
2013-01-13 17:29:37 +00:00
|
|
|
} \
|
|
|
|
\
|
2014-01-01 17:20:16 +00:00
|
|
|
inline IntFormatSpec<TYPE, TypeSpec<'X'> > hexu(TYPE value) { \
|
|
|
|
return IntFormatSpec<TYPE, TypeSpec<'X'> >(value, TypeSpec<'X'>()); \
|
2013-01-13 17:29:37 +00:00
|
|
|
} \
|
|
|
|
\
|
|
|
|
template <char TYPE_CODE> \
|
2014-01-28 20:47:37 +00:00
|
|
|
inline IntFormatSpec<TYPE, AlignTypeSpec<TYPE_CODE> > pad( \
|
2014-01-08 16:17:38 +00:00
|
|
|
IntFormatSpec<TYPE, TypeSpec<TYPE_CODE> > f, unsigned width) { \
|
2014-01-28 20:47:37 +00:00
|
|
|
return IntFormatSpec<TYPE, AlignTypeSpec<TYPE_CODE> >( \
|
|
|
|
f.value(), AlignTypeSpec<TYPE_CODE>(width, ' ')); \
|
2014-01-08 16:17:38 +00:00
|
|
|
} \
|
|
|
|
\
|
|
|
|
/* For compatibility with older compilers we provide two overloads for pad, */ \
|
|
|
|
/* one that takes a fill character and one that doesn't. In the future this */ \
|
2014-01-28 20:47:37 +00:00
|
|
|
/* can be replaced with one overload making the template argument Char */ \
|
2014-01-08 16:17:38 +00:00
|
|
|
/* default to char (C++11). */ \
|
|
|
|
template <char TYPE_CODE, typename Char> \
|
2014-01-28 20:47:37 +00:00
|
|
|
inline IntFormatSpec<TYPE, AlignTypeSpec<TYPE_CODE>, Char> pad( \
|
|
|
|
IntFormatSpec<TYPE, TypeSpec<TYPE_CODE>, Char> f, \
|
2014-01-08 16:17:38 +00:00
|
|
|
unsigned width, Char fill) { \
|
2014-01-28 20:47:37 +00:00
|
|
|
return IntFormatSpec<TYPE, AlignTypeSpec<TYPE_CODE>, Char>( \
|
|
|
|
f.value(), AlignTypeSpec<TYPE_CODE>(width, fill)); \
|
2014-01-08 16:17:38 +00:00
|
|
|
} \
|
|
|
|
\
|
2014-01-28 20:47:37 +00:00
|
|
|
inline IntFormatSpec<TYPE, AlignTypeSpec<0> > pad( \
|
2014-01-08 16:17:38 +00:00
|
|
|
TYPE value, unsigned width) { \
|
2014-01-28 20:47:37 +00:00
|
|
|
return IntFormatSpec<TYPE, AlignTypeSpec<0> >( \
|
|
|
|
value, AlignTypeSpec<0>(width, ' ')); \
|
2013-01-13 17:29:37 +00:00
|
|
|
} \
|
|
|
|
\
|
2014-01-08 16:17:38 +00:00
|
|
|
template <typename Char> \
|
2014-01-28 20:47:37 +00:00
|
|
|
inline IntFormatSpec<TYPE, AlignTypeSpec<0>, Char> pad( \
|
2014-01-08 16:17:38 +00:00
|
|
|
TYPE value, unsigned width, Char fill) { \
|
2014-01-28 20:47:37 +00:00
|
|
|
return IntFormatSpec<TYPE, AlignTypeSpec<0>, Char>( \
|
|
|
|
value, AlignTypeSpec<0>(width, fill)); \
|
2013-01-08 17:56:05 +00:00
|
|
|
}
|
|
|
|
|
2014-04-24 00:33:50 +00:00
|
|
|
FMT_DEFINE_INT_FORMATTERS(int)
|
|
|
|
FMT_DEFINE_INT_FORMATTERS(long)
|
|
|
|
FMT_DEFINE_INT_FORMATTERS(unsigned)
|
|
|
|
FMT_DEFINE_INT_FORMATTERS(unsigned long)
|
|
|
|
FMT_DEFINE_INT_FORMATTERS(LongLong)
|
|
|
|
FMT_DEFINE_INT_FORMATTERS(ULongLong)
|
2013-01-08 17:56:05 +00:00
|
|
|
|
2013-12-31 17:43:32 +00:00
|
|
|
/**
|
|
|
|
\rst
|
|
|
|
Returns a string formatter that pads the formatted argument with the fill
|
|
|
|
character to the specified width using the default (left) string alignment.
|
|
|
|
|
|
|
|
**Example**::
|
|
|
|
|
2014-10-01 15:32:01 +00:00
|
|
|
std::string s = str(MemoryWriter() << pad("abc", 8));
|
2013-12-31 17:43:32 +00:00
|
|
|
// s == "abc "
|
|
|
|
|
|
|
|
\endrst
|
|
|
|
*/
|
2014-01-01 18:00:55 +00:00
|
|
|
template <typename Char>
|
|
|
|
inline StrFormatSpec<Char> pad(
|
|
|
|
const Char *str, unsigned width, Char fill = ' ') {
|
2014-01-07 16:44:15 +00:00
|
|
|
return StrFormatSpec<Char>(str, width, fill);
|
2014-01-01 18:00:55 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
inline StrFormatSpec<wchar_t> pad(
|
|
|
|
const wchar_t *str, unsigned width, char fill = ' ') {
|
2014-01-07 16:44:15 +00:00
|
|
|
return StrFormatSpec<wchar_t>(str, width, fill);
|
2013-12-31 17:43:32 +00:00
|
|
|
}
|
|
|
|
|
2014-09-24 14:59:23 +00:00
|
|
|
// Generates a comma-separated list with results of applying f to
|
|
|
|
// numbers 0..n-1.
|
2014-06-25 14:50:16 +00:00
|
|
|
# define FMT_GEN(n, f) FMT_GEN##n(f)
|
2014-06-28 17:32:37 +00:00
|
|
|
# define FMT_GEN1(f) f(0)
|
2014-09-12 04:18:36 +00:00
|
|
|
# define FMT_GEN2(f) FMT_GEN1(f), f(1)
|
|
|
|
# define FMT_GEN3(f) FMT_GEN2(f), f(2)
|
|
|
|
# define FMT_GEN4(f) FMT_GEN3(f), f(3)
|
|
|
|
# define FMT_GEN5(f) FMT_GEN4(f), f(4)
|
|
|
|
# define FMT_GEN6(f) FMT_GEN5(f), f(5)
|
|
|
|
# define FMT_GEN7(f) FMT_GEN6(f), f(6)
|
|
|
|
# define FMT_GEN8(f) FMT_GEN7(f), f(7)
|
|
|
|
# define FMT_GEN9(f) FMT_GEN8(f), f(8)
|
|
|
|
# define FMT_GEN10(f) FMT_GEN9(f), f(9)
|
|
|
|
# define FMT_GEN11(f) FMT_GEN10(f), f(10)
|
|
|
|
# define FMT_GEN12(f) FMT_GEN11(f), f(11)
|
|
|
|
# define FMT_GEN13(f) FMT_GEN12(f), f(12)
|
|
|
|
# define FMT_GEN14(f) FMT_GEN13(f), f(13)
|
|
|
|
# define FMT_GEN15(f) FMT_GEN14(f), f(14)
|
2014-06-25 14:50:16 +00:00
|
|
|
|
2014-09-25 14:10:44 +00:00
|
|
|
namespace internal {
|
2015-03-24 15:55:40 +00:00
|
|
|
inline uint64_t make_type() { return 0; }
|
2014-09-25 14:10:44 +00:00
|
|
|
|
|
|
|
template <typename T>
|
2015-03-27 14:36:26 +00:00
|
|
|
inline uint64_t make_type(const T &arg) { return MakeValue<char>::type(arg); }
|
2014-09-25 14:10:44 +00:00
|
|
|
|
2015-05-05 14:23:32 +00:00
|
|
|
template <unsigned N>
|
|
|
|
struct ArgArray {
|
|
|
|
// Computes the argument array size by adding 1 to N, which is the number of
|
|
|
|
// arguments, if N is zero, because array of zero size is invalid, or if N
|
|
|
|
// is greater than ArgList::MAX_PACKED_ARGS to accommodate for an extra
|
|
|
|
// argument that marks the end of the list.
|
|
|
|
enum { SIZE = N + (N == 0 || N >= ArgList::MAX_PACKED_ARGS ? 1 : 0) };
|
|
|
|
|
|
|
|
typedef typename Conditional<
|
|
|
|
(N < ArgList::MAX_PACKED_ARGS), Value, Arg>::type Type[SIZE];
|
|
|
|
};
|
|
|
|
|
2014-09-25 14:10:44 +00:00
|
|
|
#if FMT_USE_VARIADIC_TEMPLATES
|
|
|
|
template <typename Arg, typename... Args>
|
2015-03-24 15:55:40 +00:00
|
|
|
inline uint64_t make_type(const Arg &first, const Args & ... tail) {
|
|
|
|
return make_type(first) | (make_type(tail...) << 4);
|
2014-09-25 14:10:44 +00:00
|
|
|
}
|
2015-05-05 14:23:32 +00:00
|
|
|
|
|
|
|
inline void do_set_types(Arg *) {}
|
|
|
|
|
|
|
|
template <typename T, typename... Args>
|
|
|
|
inline void do_set_types(Arg *args, const T &arg, const Args & ... tail) {
|
|
|
|
args->type = static_cast<Arg::Type>(MakeValue<T>::type(arg));
|
|
|
|
do_set_types(args + 1, tail...);
|
|
|
|
}
|
|
|
|
|
|
|
|
template <typename... Args>
|
|
|
|
inline void set_types(Arg *array, const Args & ... args) {
|
2015-05-05 17:00:11 +00:00
|
|
|
if (check(sizeof...(Args) > ArgList::MAX_PACKED_ARGS))
|
|
|
|
do_set_types(array, args...);
|
2015-05-05 14:23:32 +00:00
|
|
|
array[sizeof...(Args)].type = Arg::NONE;
|
|
|
|
}
|
|
|
|
|
|
|
|
template <typename... Args>
|
|
|
|
inline void set_types(Value *, const Args & ...) {
|
|
|
|
// Do nothing as types are passed separately from values.
|
|
|
|
}
|
|
|
|
|
|
|
|
template <typename Char, typename Value>
|
2015-05-08 18:20:56 +00:00
|
|
|
inline void store_args(Value *) {}
|
2015-05-05 14:23:32 +00:00
|
|
|
|
|
|
|
template <typename Char, typename Arg, typename T, typename... Args>
|
|
|
|
inline void store_args(Arg *args, const T &arg, const Args & ... tail) {
|
|
|
|
// Assign only the Value subobject of Arg and don't overwrite type (if any)
|
|
|
|
// that is assigned by set_types.
|
|
|
|
Value &value = *args;
|
|
|
|
value = MakeValue<Char>(arg);
|
|
|
|
store_args<Char>(args + 1, tail...);
|
|
|
|
}
|
|
|
|
|
|
|
|
template <typename Char, typename... Args>
|
|
|
|
ArgList make_arg_list(typename ArgArray<sizeof...(Args)>::Type array,
|
|
|
|
const Args & ... args) {
|
2015-05-05 17:00:11 +00:00
|
|
|
if (check(sizeof...(Args) >= ArgList::MAX_PACKED_ARGS))
|
2015-05-05 14:23:32 +00:00
|
|
|
set_types(array, args...);
|
|
|
|
store_args<Char>(array, args...);
|
|
|
|
return ArgList(make_type(args...), array);
|
|
|
|
}
|
2014-09-25 14:10:44 +00:00
|
|
|
#else
|
|
|
|
|
|
|
|
struct ArgType {
|
2014-09-25 14:42:29 +00:00
|
|
|
uint64_t type;
|
2014-09-25 14:10:44 +00:00
|
|
|
|
|
|
|
ArgType() : type(0) {}
|
|
|
|
|
|
|
|
template <typename T>
|
2015-03-24 15:55:40 +00:00
|
|
|
ArgType(const T &arg) : type(make_type(arg)) {}
|
2014-09-25 14:10:44 +00:00
|
|
|
};
|
|
|
|
|
2014-09-25 14:14:08 +00:00
|
|
|
# define FMT_ARG_TYPE_DEFAULT(n) ArgType t##n = ArgType()
|
|
|
|
|
2015-03-24 15:55:40 +00:00
|
|
|
inline uint64_t make_type(FMT_GEN15(FMT_ARG_TYPE_DEFAULT)) {
|
|
|
|
return t0.type | (t1.type << 4) | (t2.type << 8) | (t3.type << 12) |
|
2014-09-25 14:10:44 +00:00
|
|
|
(t4.type << 16) | (t5.type << 20) | (t6.type << 24) | (t7.type << 28) |
|
|
|
|
(t8.type << 32) | (t9.type << 36) | (t10.type << 40) | (t11.type << 44) |
|
|
|
|
(t12.type << 48) | (t13.type << 52) | (t14.type << 56);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
} // namespace internal
|
|
|
|
|
2014-06-25 14:50:16 +00:00
|
|
|
# define FMT_MAKE_TEMPLATE_ARG(n) typename T##n
|
2014-09-23 14:59:43 +00:00
|
|
|
# define FMT_MAKE_ARG_TYPE(n) T##n
|
2014-06-25 14:50:16 +00:00
|
|
|
# define FMT_MAKE_ARG(n) const T##n &v##n
|
2015-03-27 14:36:26 +00:00
|
|
|
# define FMT_MAKE_REF_char(n) fmt::internal::MakeValue<char>(v##n)
|
|
|
|
# define FMT_MAKE_REF_wchar_t(n) fmt::internal::MakeValue<wchar_t>(v##n)
|
2014-06-25 14:50:16 +00:00
|
|
|
|
2014-06-28 18:07:43 +00:00
|
|
|
#if FMT_USE_VARIADIC_TEMPLATES
|
|
|
|
// Defines a variadic function returning void.
|
|
|
|
# define FMT_VARIADIC_VOID(func, arg_type) \
|
2014-09-24 14:48:45 +00:00
|
|
|
template <typename... Args> \
|
2015-04-21 14:17:00 +00:00
|
|
|
void func(arg_type arg0, const Args & ... args) { \
|
2015-05-05 14:23:32 +00:00
|
|
|
typename fmt::internal::ArgArray<sizeof...(Args)>::Type array; \
|
|
|
|
func(arg0, fmt::internal::make_arg_list<Char>(array, args...)); \
|
2014-06-28 18:07:43 +00:00
|
|
|
}
|
2014-06-30 21:26:29 +00:00
|
|
|
|
|
|
|
// Defines a variadic constructor.
|
|
|
|
# define FMT_VARIADIC_CTOR(ctor, func, arg0_type, arg1_type) \
|
2014-09-24 14:48:45 +00:00
|
|
|
template <typename... Args> \
|
2014-06-30 21:26:29 +00:00
|
|
|
ctor(arg0_type arg0, arg1_type arg1, const Args & ... args) { \
|
2015-05-05 14:23:32 +00:00
|
|
|
typename fmt::internal::ArgArray<sizeof...(Args)>::Type array; \
|
|
|
|
func(arg0, arg1, fmt::internal::make_arg_list<Char>(array, args...)); \
|
2014-06-30 21:26:29 +00:00
|
|
|
}
|
|
|
|
|
2014-06-28 18:07:43 +00:00
|
|
|
#else
|
2014-06-30 21:26:29 +00:00
|
|
|
|
2015-03-27 14:36:26 +00:00
|
|
|
# define FMT_MAKE_REF(n) fmt::internal::MakeValue<Char>(v##n)
|
2014-09-24 14:48:45 +00:00
|
|
|
# define FMT_MAKE_REF2(n) v##n
|
|
|
|
|
2014-06-28 16:15:51 +00:00
|
|
|
// Defines a wrapper for a function taking one argument of type arg_type
|
|
|
|
// and n additional arguments of arbitrary types.
|
2014-06-28 18:07:43 +00:00
|
|
|
# define FMT_WRAP1(func, arg_type, n) \
|
2014-06-25 02:27:26 +00:00
|
|
|
template <FMT_GEN(n, FMT_MAKE_TEMPLATE_ARG)> \
|
2014-06-25 14:50:16 +00:00
|
|
|
inline void func(arg_type arg1, FMT_GEN(n, FMT_MAKE_ARG)) { \
|
2015-05-05 14:23:32 +00:00
|
|
|
const fmt::internal::ArgArray<n>::Type array = {FMT_GEN(n, FMT_MAKE_REF)}; \
|
2014-09-23 14:59:43 +00:00
|
|
|
func(arg1, fmt::ArgList( \
|
2015-05-05 14:23:32 +00:00
|
|
|
fmt::internal::make_type(FMT_GEN(n, FMT_MAKE_REF2)), array)); \
|
2014-06-25 02:27:26 +00:00
|
|
|
}
|
|
|
|
|
2014-06-25 14:50:16 +00:00
|
|
|
// Emulates a variadic function returning void on a pre-C++11 compiler.
|
|
|
|
# define FMT_VARIADIC_VOID(func, arg_type) \
|
2015-02-16 22:32:38 +00:00
|
|
|
inline void func(arg_type arg) { func(arg, fmt::ArgList()); } \
|
2014-06-28 18:07:43 +00:00
|
|
|
FMT_WRAP1(func, arg_type, 1) FMT_WRAP1(func, arg_type, 2) \
|
|
|
|
FMT_WRAP1(func, arg_type, 3) FMT_WRAP1(func, arg_type, 4) \
|
|
|
|
FMT_WRAP1(func, arg_type, 5) FMT_WRAP1(func, arg_type, 6) \
|
|
|
|
FMT_WRAP1(func, arg_type, 7) FMT_WRAP1(func, arg_type, 8) \
|
|
|
|
FMT_WRAP1(func, arg_type, 9) FMT_WRAP1(func, arg_type, 10)
|
2014-06-30 21:26:29 +00:00
|
|
|
|
|
|
|
# define FMT_CTOR(ctor, func, arg0_type, arg1_type, n) \
|
|
|
|
template <FMT_GEN(n, FMT_MAKE_TEMPLATE_ARG)> \
|
|
|
|
ctor(arg0_type arg0, arg1_type arg1, FMT_GEN(n, FMT_MAKE_ARG)) { \
|
2015-05-05 14:23:32 +00:00
|
|
|
const fmt::internal::ArgArray<n>::Type array = {FMT_GEN(n, FMT_MAKE_REF)}; \
|
2014-09-23 14:59:43 +00:00
|
|
|
func(arg0, arg1, fmt::ArgList( \
|
2015-05-05 14:23:32 +00:00
|
|
|
fmt::internal::make_type(FMT_GEN(n, FMT_MAKE_REF2)), array)); \
|
2014-06-30 21:26:29 +00:00
|
|
|
}
|
|
|
|
|
2014-07-01 23:23:50 +00:00
|
|
|
// Emulates a variadic constructor on a pre-C++11 compiler.
|
2014-06-30 21:26:29 +00:00
|
|
|
# define FMT_VARIADIC_CTOR(ctor, func, arg0_type, arg1_type) \
|
|
|
|
FMT_CTOR(ctor, func, arg0_type, arg1_type, 1) \
|
|
|
|
FMT_CTOR(ctor, func, arg0_type, arg1_type, 2) \
|
|
|
|
FMT_CTOR(ctor, func, arg0_type, arg1_type, 3) \
|
|
|
|
FMT_CTOR(ctor, func, arg0_type, arg1_type, 4) \
|
|
|
|
FMT_CTOR(ctor, func, arg0_type, arg1_type, 5) \
|
|
|
|
FMT_CTOR(ctor, func, arg0_type, arg1_type, 6) \
|
|
|
|
FMT_CTOR(ctor, func, arg0_type, arg1_type, 7) \
|
|
|
|
FMT_CTOR(ctor, func, arg0_type, arg1_type, 8) \
|
|
|
|
FMT_CTOR(ctor, func, arg0_type, arg1_type, 9) \
|
|
|
|
FMT_CTOR(ctor, func, arg0_type, arg1_type, 10)
|
2014-06-25 14:50:16 +00:00
|
|
|
#endif
|
2014-06-25 02:27:26 +00:00
|
|
|
|
2014-06-28 17:32:37 +00:00
|
|
|
// Generates a comma-separated list with results of applying f to pairs
|
|
|
|
// (argument, index).
|
|
|
|
#define FMT_FOR_EACH1(f, x0) f(x0, 0)
|
|
|
|
#define FMT_FOR_EACH2(f, x0, x1) \
|
|
|
|
FMT_FOR_EACH1(f, x0), f(x1, 1)
|
|
|
|
#define FMT_FOR_EACH3(f, x0, x1, x2) \
|
|
|
|
FMT_FOR_EACH2(f, x0 ,x1), f(x2, 2)
|
|
|
|
#define FMT_FOR_EACH4(f, x0, x1, x2, x3) \
|
|
|
|
FMT_FOR_EACH3(f, x0, x1, x2), f(x3, 3)
|
|
|
|
#define FMT_FOR_EACH5(f, x0, x1, x2, x3, x4) \
|
|
|
|
FMT_FOR_EACH4(f, x0, x1, x2, x3), f(x4, 4)
|
|
|
|
#define FMT_FOR_EACH6(f, x0, x1, x2, x3, x4, x5) \
|
|
|
|
FMT_FOR_EACH5(f, x0, x1, x2, x3, x4), f(x5, 5)
|
|
|
|
#define FMT_FOR_EACH7(f, x0, x1, x2, x3, x4, x5, x6) \
|
|
|
|
FMT_FOR_EACH6(f, x0, x1, x2, x3, x4, x5), f(x6, 6)
|
|
|
|
#define FMT_FOR_EACH8(f, x0, x1, x2, x3, x4, x5, x6, x7) \
|
|
|
|
FMT_FOR_EACH7(f, x0, x1, x2, x3, x4, x5, x6), f(x7, 7)
|
|
|
|
#define FMT_FOR_EACH9(f, x0, x1, x2, x3, x4, x5, x6, x7, x8) \
|
|
|
|
FMT_FOR_EACH8(f, x0, x1, x2, x3, x4, x5, x6, x7), f(x8, 8)
|
|
|
|
#define FMT_FOR_EACH10(f, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9) \
|
|
|
|
FMT_FOR_EACH9(f, x0, x1, x2, x3, x4, x5, x6, x7, x8), f(x9, 9)
|
|
|
|
|
2014-06-30 21:26:29 +00:00
|
|
|
/**
|
2014-09-24 14:59:23 +00:00
|
|
|
An error returned by an operating system or a language runtime,
|
|
|
|
for example a file opening error.
|
2014-06-30 21:26:29 +00:00
|
|
|
*/
|
2014-07-02 04:01:15 +00:00
|
|
|
class SystemError : public internal::RuntimeError {
|
2014-06-30 21:26:29 +00:00
|
|
|
private:
|
2015-06-26 14:43:54 +00:00
|
|
|
void init(int err_code, CStringRef format_str, ArgList args);
|
2014-06-30 21:26:29 +00:00
|
|
|
|
|
|
|
protected:
|
|
|
|
int error_code_;
|
|
|
|
|
2014-07-01 00:17:48 +00:00
|
|
|
typedef char Char; // For FMT_VARIADIC_CTOR.
|
|
|
|
|
2014-06-30 23:31:43 +00:00
|
|
|
SystemError() {}
|
|
|
|
|
2014-06-30 21:26:29 +00:00
|
|
|
public:
|
|
|
|
/**
|
|
|
|
\rst
|
2014-12-18 16:36:53 +00:00
|
|
|
Constructs a :class:`fmt::SystemError` object with the description
|
2015-02-06 16:43:02 +00:00
|
|
|
of the form
|
|
|
|
|
|
|
|
.. parsed-literal::
|
|
|
|
*<message>*: *<system-message>*
|
2015-02-12 20:46:28 +00:00
|
|
|
|
2015-02-06 16:43:02 +00:00
|
|
|
where *<message>* is the formatted message and *<system-message>* is
|
|
|
|
the system message corresponding to the error code.
|
2014-06-30 21:26:29 +00:00
|
|
|
*error_code* is a system error code as given by ``errno``.
|
2015-02-07 17:46:42 +00:00
|
|
|
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.
|
2015-02-06 16:43:02 +00:00
|
|
|
|
2015-02-06 16:45:43 +00:00
|
|
|
**Example**::
|
2015-02-06 16:43:02 +00:00
|
|
|
|
|
|
|
// This throws a SystemError 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::SystemError(errno, "cannot open file '{}'", filename);
|
2014-06-30 21:26:29 +00:00
|
|
|
\endrst
|
|
|
|
*/
|
2015-06-26 14:43:54 +00:00
|
|
|
SystemError(int error_code, CStringRef message) {
|
2014-06-30 21:26:29 +00:00
|
|
|
init(error_code, message, ArgList());
|
|
|
|
}
|
2015-06-26 14:43:54 +00:00
|
|
|
FMT_VARIADIC_CTOR(SystemError, init, int, CStringRef)
|
2014-06-30 21:26:29 +00:00
|
|
|
|
|
|
|
int error_code() const { return error_code_; }
|
|
|
|
};
|
|
|
|
|
2013-09-05 03:44:13 +00:00
|
|
|
/**
|
2013-09-08 22:37:14 +00:00
|
|
|
\rst
|
2013-09-05 03:44:13 +00:00
|
|
|
This template provides operations for formatting and writing data into
|
2014-10-01 15:32:01 +00:00
|
|
|
a character stream. The output is stored in a buffer provided by a subclass
|
2014-12-18 16:36:53 +00:00
|
|
|
such as :class:`fmt::BasicMemoryWriter`.
|
2013-09-08 22:37:14 +00:00
|
|
|
|
2014-10-01 15:32:01 +00:00
|
|
|
You can use one of the following typedefs for common character types:
|
2013-09-08 22:37:14 +00:00
|
|
|
|
2014-10-01 15:32:01 +00:00
|
|
|
+---------+----------------------+
|
|
|
|
| Type | Definition |
|
|
|
|
+=========+======================+
|
|
|
|
| Writer | BasicWriter<char> |
|
|
|
|
+---------+----------------------+
|
|
|
|
| WWriter | BasicWriter<wchar_t> |
|
|
|
|
+---------+----------------------+
|
2013-09-08 22:37:14 +00:00
|
|
|
|
|
|
|
\endrst
|
2013-09-05 03:44:13 +00:00
|
|
|
*/
|
2014-09-29 15:48:16 +00:00
|
|
|
template <typename Char>
|
2013-02-03 04:29:02 +00:00
|
|
|
class BasicWriter {
|
2013-09-05 02:23:55 +00:00
|
|
|
private:
|
2014-04-25 14:40:37 +00:00
|
|
|
// Output buffer.
|
2015-03-20 13:31:24 +00:00
|
|
|
Buffer<Char> &buffer_;
|
2014-09-29 15:48:16 +00:00
|
|
|
|
|
|
|
FMT_DISALLOW_COPY_AND_ASSIGN(BasicWriter);
|
2013-09-05 02:23:55 +00:00
|
|
|
|
2014-02-14 18:36:17 +00:00
|
|
|
typedef typename internal::CharTraits<Char>::CharPtr CharPtr;
|
|
|
|
|
2013-09-03 15:16:53 +00:00
|
|
|
#if _SECURE_SCL
|
2014-07-28 15:41:50 +00:00
|
|
|
// Returns pointer value.
|
|
|
|
static Char *get(CharPtr p) { return p.base(); }
|
2013-09-03 15:16:53 +00:00
|
|
|
#else
|
2014-07-28 15:41:50 +00:00
|
|
|
static Char *get(Char *p) { return p; }
|
2013-09-03 15:16:53 +00:00
|
|
|
#endif
|
|
|
|
|
2014-09-19 14:51:42 +00:00
|
|
|
// Fills the padding around the content and returns the pointer to the
|
|
|
|
// content area.
|
2014-07-28 15:41:50 +00:00
|
|
|
static CharPtr fill_padding(CharPtr buffer,
|
2013-09-08 20:07:04 +00:00
|
|
|
unsigned total_size, std::size_t content_size, wchar_t fill);
|
2013-01-08 17:56:05 +00:00
|
|
|
|
2012-12-26 01:55:41 +00:00
|
|
|
// Grows the buffer by n characters and returns a pointer to the newly
|
|
|
|
// allocated area.
|
2014-07-28 15:41:50 +00:00
|
|
|
CharPtr grow_buffer(std::size_t n) {
|
2012-12-26 01:55:41 +00:00
|
|
|
std::size_t size = buffer_.size();
|
|
|
|
buffer_.resize(size + n);
|
2014-07-25 15:41:22 +00:00
|
|
|
return internal::make_ptr(&buffer_[size], n);
|
2012-12-26 01:55:41 +00:00
|
|
|
}
|
|
|
|
|
2015-07-31 15:02:38 +00:00
|
|
|
// Writes an unsigned decimal integer.
|
|
|
|
template <typename UInt>
|
|
|
|
Char *write_unsigned_decimal(UInt value, unsigned prefix_size = 0) {
|
|
|
|
unsigned num_digits = internal::count_digits(value);
|
|
|
|
Char *ptr = get(grow_buffer(prefix_size + num_digits));
|
|
|
|
internal::format_decimal(ptr + prefix_size, value, num_digits);
|
|
|
|
return ptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Writes a decimal integer.
|
|
|
|
template <typename Int>
|
|
|
|
void write_decimal(Int value) {
|
|
|
|
typename internal::IntTraits<Int>::MainType abs_value = value;
|
|
|
|
if (internal::is_negative(value)) {
|
|
|
|
abs_value = 0 - abs_value;
|
|
|
|
*write_unsigned_decimal(abs_value, 1) = '-';
|
|
|
|
} else {
|
|
|
|
write_unsigned_decimal(abs_value, 0);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-06-07 15:57:55 +00:00
|
|
|
// Prepare a buffer for integer formatting.
|
2014-07-28 15:41:50 +00:00
|
|
|
CharPtr prepare_int_buffer(unsigned num_digits,
|
2014-06-07 15:57:55 +00:00
|
|
|
const EmptySpec &, const char *prefix, unsigned prefix_size) {
|
|
|
|
unsigned size = prefix_size + num_digits;
|
2014-07-28 15:41:50 +00:00
|
|
|
CharPtr p = grow_buffer(size);
|
2014-06-07 15:57:55 +00:00
|
|
|
std::copy(prefix, prefix + prefix_size, p);
|
2013-01-08 17:56:05 +00:00
|
|
|
return p + size - 1;
|
|
|
|
}
|
|
|
|
|
2014-06-20 14:34:02 +00:00
|
|
|
template <typename Spec>
|
2014-07-28 15:41:50 +00:00
|
|
|
CharPtr prepare_int_buffer(unsigned num_digits,
|
2014-06-20 14:34:02 +00:00
|
|
|
const Spec &spec, const char *prefix, unsigned prefix_size);
|
2014-01-28 20:47:37 +00:00
|
|
|
|
|
|
|
// Formats an integer.
|
|
|
|
template <typename T, typename Spec>
|
2014-09-29 15:48:16 +00:00
|
|
|
void write_int(T value, Spec spec);
|
2013-01-04 17:14:34 +00:00
|
|
|
|
2013-09-08 22:37:14 +00:00
|
|
|
// Formats a floating-point number (double or long double).
|
2013-01-04 17:14:34 +00:00
|
|
|
template <typename T>
|
2014-07-24 15:53:27 +00:00
|
|
|
void write_double(T value, const FormatSpec &spec);
|
2013-01-04 17:14:34 +00:00
|
|
|
|
2014-06-30 21:26:29 +00:00
|
|
|
// Writes a formatted string.
|
2014-07-26 16:45:03 +00:00
|
|
|
template <typename StrChar>
|
2014-06-30 21:26:29 +00:00
|
|
|
CharPtr write_str(
|
2014-07-26 16:45:03 +00:00
|
|
|
const StrChar *s, std::size_t size, const AlignSpec &spec);
|
2013-01-04 17:14:34 +00:00
|
|
|
|
2014-07-26 16:45:03 +00:00
|
|
|
template <typename StrChar>
|
2014-06-30 21:26:29 +00:00
|
|
|
void write_str(
|
2014-07-26 16:45:03 +00:00
|
|
|
const internal::Arg::StringValue<StrChar> &str, const FormatSpec &spec);
|
2014-06-24 14:54:26 +00:00
|
|
|
|
2015-02-26 14:21:54 +00:00
|
|
|
// This following methods are private to disallow writing wide characters
|
|
|
|
// and strings to a char stream. If you want to print a wide string as a
|
|
|
|
// pointer as std::ostream does, cast it to const void*.
|
2013-09-10 05:21:40 +00:00
|
|
|
// Do not implement!
|
2015-02-26 14:54:12 +00:00
|
|
|
void operator<<(typename internal::WCharHelper<wchar_t, Char>::Unsupported);
|
2015-02-26 14:32:00 +00:00
|
|
|
void operator<<(
|
|
|
|
typename internal::WCharHelper<const wchar_t *, Char>::Unsupported);
|
2015-02-26 14:21:54 +00:00
|
|
|
|
2014-12-03 14:33:31 +00:00
|
|
|
// Appends floating-point length specifier to the format string.
|
|
|
|
// The second argument is only used for overload resolution.
|
|
|
|
void append_float_length(Char *&format_ptr, long double) {
|
|
|
|
*format_ptr++ = 'L';
|
|
|
|
}
|
|
|
|
|
2014-11-25 23:01:09 +00:00
|
|
|
template<typename T>
|
2014-12-03 14:33:31 +00:00
|
|
|
void append_float_length(Char *&, T) {}
|
2014-11-25 23:01:09 +00:00
|
|
|
|
2015-06-16 14:36:32 +00:00
|
|
|
template <typename Impl, typename Char_>
|
|
|
|
friend class internal::BasicArgFormatter;
|
|
|
|
|
|
|
|
friend class internal::PrintfArgFormatter<Char>;
|
2014-06-06 13:38:37 +00:00
|
|
|
|
2014-10-01 15:32:01 +00:00
|
|
|
protected:
|
2014-05-13 15:55:13 +00:00
|
|
|
/**
|
|
|
|
Constructs a ``BasicWriter`` object.
|
|
|
|
*/
|
2015-03-20 13:31:24 +00:00
|
|
|
explicit BasicWriter(Buffer<Char> &b) : buffer_(b) {}
|
2014-04-25 14:40:37 +00:00
|
|
|
|
2014-10-01 15:32:01 +00:00
|
|
|
public:
|
|
|
|
/**
|
2015-05-22 14:08:16 +00:00
|
|
|
\rst
|
2014-10-01 15:32:01 +00:00
|
|
|
Destroys a ``BasicWriter`` object.
|
2015-05-22 14:08:16 +00:00
|
|
|
\endrst
|
2014-10-01 15:32:01 +00:00
|
|
|
*/
|
|
|
|
virtual ~BasicWriter() {}
|
|
|
|
|
2013-01-04 17:14:34 +00:00
|
|
|
/**
|
2014-05-13 15:55:13 +00:00
|
|
|
Returns the total number of characters written.
|
2013-01-04 17:14:34 +00:00
|
|
|
*/
|
|
|
|
std::size_t size() const { return buffer_.size(); }
|
|
|
|
|
|
|
|
/**
|
|
|
|
Returns a pointer to the output buffer content. No terminating null
|
|
|
|
character is appended.
|
|
|
|
*/
|
2015-02-14 01:58:29 +00:00
|
|
|
const Char *data() const FMT_NOEXCEPT { return &buffer_[0]; }
|
2013-01-04 17:14:34 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
Returns a pointer to the output buffer content with terminating null
|
|
|
|
character appended.
|
|
|
|
*/
|
2013-01-27 00:07:28 +00:00
|
|
|
const Char *c_str() const {
|
2013-01-04 17:14:34 +00:00
|
|
|
std::size_t size = buffer_.size();
|
|
|
|
buffer_.reserve(size + 1);
|
|
|
|
buffer_[size] = '\0';
|
|
|
|
return &buffer_[0];
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2015-05-22 14:22:55 +00:00
|
|
|
\rst
|
2013-01-13 15:14:54 +00:00
|
|
|
Returns the content of the output buffer as an `std::string`.
|
2015-05-22 14:22:55 +00:00
|
|
|
\endrst
|
2013-01-04 17:14:34 +00:00
|
|
|
*/
|
2013-01-27 00:07:28 +00:00
|
|
|
std::basic_string<Char> str() const {
|
|
|
|
return std::basic_string<Char>(&buffer_[0], buffer_.size());
|
|
|
|
}
|
2013-01-04 17:14:34 +00:00
|
|
|
|
2013-09-08 22:37:14 +00:00
|
|
|
/**
|
|
|
|
\rst
|
2014-06-29 18:51:10 +00:00
|
|
|
Writes formatted data.
|
|
|
|
|
|
|
|
*args* is an argument list representing arbitrary arguments.
|
2013-09-08 22:37:14 +00:00
|
|
|
|
|
|
|
**Example**::
|
|
|
|
|
2014-10-01 15:32:01 +00:00
|
|
|
MemoryWriter out;
|
2014-06-29 18:51:10 +00:00
|
|
|
out.write("Current point:\n");
|
|
|
|
out.write("({:+f}, {:+f})", -3.14, 3.14);
|
2013-09-08 22:37:14 +00:00
|
|
|
|
|
|
|
This will write the following output to the ``out`` object:
|
|
|
|
|
|
|
|
.. code-block:: none
|
|
|
|
|
|
|
|
Current point:
|
|
|
|
(-3.140000, +3.140000)
|
|
|
|
|
2015-02-16 22:33:04 +00:00
|
|
|
The output can be accessed using :func:`data()`, :func:`c_str` or
|
|
|
|
:func:`str` methods.
|
2013-09-08 22:37:14 +00:00
|
|
|
|
2014-10-10 15:40:35 +00:00
|
|
|
See also :ref:`syntax`.
|
2013-09-08 22:37:14 +00:00
|
|
|
\endrst
|
|
|
|
*/
|
2015-06-26 14:43:54 +00:00
|
|
|
void write(BasicCStringRef<Char> format, ArgList args) {
|
2015-07-28 15:09:29 +00:00
|
|
|
BasicFormatter<Char>(args, *this).format(format);
|
2014-06-25 14:50:16 +00:00
|
|
|
}
|
2015-06-26 14:43:54 +00:00
|
|
|
FMT_VARIADIC_VOID(write, BasicCStringRef<Char>)
|
2014-06-25 14:50:16 +00:00
|
|
|
|
2013-02-03 04:29:02 +00:00
|
|
|
BasicWriter &operator<<(int value) {
|
2015-07-31 15:02:38 +00:00
|
|
|
write_decimal(value);
|
|
|
|
return *this;
|
2013-01-08 17:56:05 +00:00
|
|
|
}
|
2013-02-03 04:29:02 +00:00
|
|
|
BasicWriter &operator<<(unsigned value) {
|
2014-01-28 20:47:37 +00:00
|
|
|
return *this << IntFormatSpec<unsigned>(value);
|
2013-01-08 17:56:05 +00:00
|
|
|
}
|
2013-09-08 21:18:08 +00:00
|
|
|
BasicWriter &operator<<(long value) {
|
2015-07-31 15:02:38 +00:00
|
|
|
write_decimal(value);
|
|
|
|
return *this;
|
2013-09-08 21:18:08 +00:00
|
|
|
}
|
2013-09-09 22:12:51 +00:00
|
|
|
BasicWriter &operator<<(unsigned long value) {
|
2014-01-28 20:47:37 +00:00
|
|
|
return *this << IntFormatSpec<unsigned long>(value);
|
2013-09-09 22:12:51 +00:00
|
|
|
}
|
2014-02-15 17:58:33 +00:00
|
|
|
BasicWriter &operator<<(LongLong value) {
|
2015-07-31 15:02:38 +00:00
|
|
|
write_decimal(value);
|
|
|
|
return *this;
|
2013-09-09 22:12:51 +00:00
|
|
|
}
|
2013-09-08 22:37:14 +00:00
|
|
|
|
|
|
|
/**
|
2015-05-22 14:08:16 +00:00
|
|
|
\rst
|
2013-09-08 23:27:12 +00:00
|
|
|
Formats *value* and writes it to the stream.
|
2015-05-22 14:08:16 +00:00
|
|
|
\endrst
|
2013-09-08 22:37:14 +00:00
|
|
|
*/
|
2014-02-15 18:02:02 +00:00
|
|
|
BasicWriter &operator<<(ULongLong value) {
|
|
|
|
return *this << IntFormatSpec<ULongLong>(value);
|
2013-09-08 21:18:08 +00:00
|
|
|
}
|
|
|
|
|
2013-09-08 23:27:12 +00:00
|
|
|
BasicWriter &operator<<(double value) {
|
2014-07-24 15:53:27 +00:00
|
|
|
write_double(value, FormatSpec());
|
2013-09-08 23:27:12 +00:00
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
2013-09-08 22:37:14 +00:00
|
|
|
/**
|
2015-05-22 14:08:16 +00:00
|
|
|
\rst
|
2013-09-08 23:27:12 +00:00
|
|
|
Formats *value* using the general format for floating-point numbers
|
|
|
|
(``'g'``) and writes it to the stream.
|
2015-05-22 14:08:16 +00:00
|
|
|
\endrst
|
2013-09-08 22:37:14 +00:00
|
|
|
*/
|
2013-09-08 23:27:12 +00:00
|
|
|
BasicWriter &operator<<(long double value) {
|
2014-07-24 15:53:27 +00:00
|
|
|
write_double(value, FormatSpec());
|
2013-02-27 21:17:09 +00:00
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
2014-01-02 19:30:28 +00:00
|
|
|
/**
|
2014-04-28 15:59:29 +00:00
|
|
|
Writes a character to the stream.
|
2014-01-02 19:30:28 +00:00
|
|
|
*/
|
2013-09-10 05:21:40 +00:00
|
|
|
BasicWriter &operator<<(char value) {
|
2014-07-24 15:53:27 +00:00
|
|
|
buffer_.push_back(value);
|
2013-01-08 17:56:05 +00:00
|
|
|
return *this;
|
2013-01-04 17:14:34 +00:00
|
|
|
}
|
|
|
|
|
2015-02-26 14:21:54 +00:00
|
|
|
BasicWriter &operator<<(
|
|
|
|
typename internal::WCharHelper<wchar_t, Char>::Supported value) {
|
|
|
|
buffer_.push_back(value);
|
2014-01-02 19:30:28 +00:00
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
2013-09-10 16:26:11 +00:00
|
|
|
/**
|
2015-05-22 14:08:16 +00:00
|
|
|
\rst
|
2013-09-10 16:26:11 +00:00
|
|
|
Writes *value* to the stream.
|
2015-05-22 14:08:16 +00:00
|
|
|
\endrst
|
2013-09-10 16:26:11 +00:00
|
|
|
*/
|
2014-07-24 15:53:27 +00:00
|
|
|
BasicWriter &operator<<(fmt::BasicStringRef<Char> value) {
|
2015-06-26 14:43:54 +00:00
|
|
|
const Char *str = value.data();
|
2014-07-24 15:53:27 +00:00
|
|
|
buffer_.append(str, str + value.size());
|
2013-01-08 17:56:05 +00:00
|
|
|
return *this;
|
2013-01-04 17:14:34 +00:00
|
|
|
}
|
|
|
|
|
2015-06-17 15:07:05 +00:00
|
|
|
BasicWriter &operator<<(
|
|
|
|
typename internal::WCharHelper<StringRef, Char>::Supported value) {
|
2015-06-26 14:43:54 +00:00
|
|
|
const char *str = value.data();
|
2015-06-09 15:20:44 +00:00
|
|
|
buffer_.append(str, str + value.size());
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
2014-01-28 20:47:37 +00:00
|
|
|
template <typename T, typename Spec, typename FillChar>
|
2014-09-29 15:48:16 +00:00
|
|
|
BasicWriter &operator<<(IntFormatSpec<T, Spec, FillChar> spec) {
|
2014-07-04 14:18:44 +00:00
|
|
|
internal::CharTraits<Char>::convert(FillChar());
|
2014-07-24 15:53:27 +00:00
|
|
|
write_int(spec.value(), spec);
|
2014-01-28 20:47:37 +00:00
|
|
|
return *this;
|
|
|
|
}
|
2013-01-08 17:56:05 +00:00
|
|
|
|
2014-07-26 16:45:03 +00:00
|
|
|
template <typename StrChar>
|
|
|
|
BasicWriter &operator<<(const StrFormatSpec<StrChar> &spec) {
|
|
|
|
const StrChar *s = spec.str();
|
2014-06-30 21:26:29 +00:00
|
|
|
write_str(s, std::char_traits<Char>::length(s), spec);
|
2013-12-31 17:43:32 +00:00
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
2015-02-14 01:58:29 +00:00
|
|
|
void clear() FMT_NOEXCEPT { buffer_.clear(); }
|
2012-12-26 01:55:41 +00:00
|
|
|
};
|
|
|
|
|
2014-09-29 15:48:16 +00:00
|
|
|
template <typename Char>
|
2014-07-26 16:45:03 +00:00
|
|
|
template <typename StrChar>
|
2014-10-01 15:32:01 +00:00
|
|
|
typename BasicWriter<Char>::CharPtr BasicWriter<Char>::write_str(
|
|
|
|
const StrChar *s, std::size_t size, const AlignSpec &spec) {
|
2013-09-03 15:16:53 +00:00
|
|
|
CharPtr out = CharPtr();
|
2013-01-27 00:07:28 +00:00
|
|
|
if (spec.width() > size) {
|
2014-07-28 15:41:50 +00:00
|
|
|
out = grow_buffer(spec.width());
|
2015-06-17 14:21:16 +00:00
|
|
|
Char fill = internal::CharTraits<Char>::cast(spec.fill());
|
2013-01-27 00:07:28 +00:00
|
|
|
if (spec.align() == ALIGN_RIGHT) {
|
2013-09-08 20:47:06 +00:00
|
|
|
std::fill_n(out, spec.width() - size, fill);
|
2013-01-27 00:07:28 +00:00
|
|
|
out += spec.width() - size;
|
|
|
|
} else if (spec.align() == ALIGN_CENTER) {
|
2014-07-28 15:41:50 +00:00
|
|
|
out = fill_padding(out, spec.width(), size, fill);
|
2013-01-27 00:07:28 +00:00
|
|
|
} else {
|
2013-09-08 20:47:06 +00:00
|
|
|
std::fill_n(out + size, spec.width() - size, fill);
|
2013-01-27 00:07:28 +00:00
|
|
|
}
|
|
|
|
} else {
|
2014-07-28 15:41:50 +00:00
|
|
|
out = grow_buffer(size);
|
2013-01-27 00:07:28 +00:00
|
|
|
}
|
|
|
|
std::copy(s, s + size, out);
|
|
|
|
return out;
|
|
|
|
}
|
|
|
|
|
2014-09-29 15:48:16 +00:00
|
|
|
template <typename Char>
|
|
|
|
typename BasicWriter<Char>::CharPtr
|
|
|
|
BasicWriter<Char>::fill_padding(
|
2014-09-19 14:51:42 +00:00
|
|
|
CharPtr buffer, unsigned total_size,
|
|
|
|
std::size_t content_size, wchar_t fill) {
|
|
|
|
std::size_t padding = total_size - content_size;
|
|
|
|
std::size_t left_padding = padding / 2;
|
2015-06-17 14:21:16 +00:00
|
|
|
Char fill_char = internal::CharTraits<Char>::cast(fill);
|
2014-09-19 14:51:42 +00:00
|
|
|
std::fill_n(buffer, left_padding, fill_char);
|
|
|
|
buffer += left_padding;
|
|
|
|
CharPtr content = buffer;
|
|
|
|
std::fill_n(buffer + content_size, padding - left_padding, fill_char);
|
|
|
|
return content;
|
|
|
|
}
|
|
|
|
|
2014-09-29 15:48:16 +00:00
|
|
|
template <typename Char>
|
2014-06-20 14:34:02 +00:00
|
|
|
template <typename Spec>
|
2014-09-29 15:48:16 +00:00
|
|
|
typename BasicWriter<Char>::CharPtr
|
|
|
|
BasicWriter<Char>::prepare_int_buffer(
|
2014-06-20 14:59:23 +00:00
|
|
|
unsigned num_digits, const Spec &spec,
|
|
|
|
const char *prefix, unsigned prefix_size) {
|
|
|
|
unsigned width = spec.width();
|
2014-06-21 15:18:05 +00:00
|
|
|
Alignment align = spec.align();
|
2015-06-17 14:21:16 +00:00
|
|
|
Char fill = internal::CharTraits<Char>::cast(spec.fill());
|
2014-06-20 14:59:23 +00:00
|
|
|
if (spec.precision() > static_cast<int>(num_digits)) {
|
|
|
|
// Octal prefix '0' is counted as a digit, so ignore it if precision
|
|
|
|
// is specified.
|
2014-06-20 15:04:44 +00:00
|
|
|
if (prefix_size > 0 && prefix[prefix_size - 1] == '0')
|
|
|
|
--prefix_size;
|
2014-06-20 14:59:23 +00:00
|
|
|
unsigned number_size = prefix_size + spec.precision();
|
2014-06-21 15:18:05 +00:00
|
|
|
AlignSpec subspec(number_size, '0', ALIGN_NUMERIC);
|
|
|
|
if (number_size >= width)
|
2014-07-28 15:41:50 +00:00
|
|
|
return prepare_int_buffer(num_digits, subspec, prefix, prefix_size);
|
2014-06-21 15:18:05 +00:00
|
|
|
buffer_.reserve(width);
|
|
|
|
unsigned fill_size = width - number_size;
|
|
|
|
if (align != ALIGN_LEFT) {
|
2014-07-28 15:41:50 +00:00
|
|
|
CharPtr p = grow_buffer(fill_size);
|
2014-07-01 00:46:14 +00:00
|
|
|
std::fill(p, p + fill_size, fill);
|
2014-06-21 15:18:05 +00:00
|
|
|
}
|
2014-07-28 15:41:50 +00:00
|
|
|
CharPtr result = prepare_int_buffer(
|
2014-07-26 16:45:03 +00:00
|
|
|
num_digits, subspec, prefix, prefix_size);
|
2014-06-21 15:18:05 +00:00
|
|
|
if (align == ALIGN_LEFT) {
|
2014-07-28 15:41:50 +00:00
|
|
|
CharPtr p = grow_buffer(fill_size);
|
2014-07-01 00:46:14 +00:00
|
|
|
std::fill(p, p + fill_size, fill);
|
2014-06-20 14:59:23 +00:00
|
|
|
}
|
2014-06-21 15:18:05 +00:00
|
|
|
return result;
|
2014-06-20 14:34:02 +00:00
|
|
|
}
|
|
|
|
unsigned size = prefix_size + num_digits;
|
|
|
|
if (width <= size) {
|
2014-07-28 15:41:50 +00:00
|
|
|
CharPtr p = grow_buffer(size);
|
2014-06-20 14:34:02 +00:00
|
|
|
std::copy(prefix, prefix + prefix_size, p);
|
|
|
|
return p + size - 1;
|
|
|
|
}
|
2014-07-28 15:41:50 +00:00
|
|
|
CharPtr p = grow_buffer(width);
|
2014-06-20 14:34:02 +00:00
|
|
|
CharPtr end = p + width;
|
|
|
|
if (align == ALIGN_LEFT) {
|
|
|
|
std::copy(prefix, prefix + prefix_size, p);
|
|
|
|
p += size;
|
|
|
|
std::fill(p, end, fill);
|
|
|
|
} else if (align == ALIGN_CENTER) {
|
2014-07-28 15:41:50 +00:00
|
|
|
p = fill_padding(p, width, size, fill);
|
2014-06-20 14:34:02 +00:00
|
|
|
std::copy(prefix, prefix + prefix_size, p);
|
|
|
|
p += size;
|
|
|
|
} else {
|
|
|
|
if (align == ALIGN_NUMERIC) {
|
|
|
|
if (prefix_size != 0) {
|
|
|
|
p = std::copy(prefix, prefix + prefix_size, p);
|
|
|
|
size -= prefix_size;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
std::copy(prefix, prefix + prefix_size, end - size);
|
|
|
|
}
|
|
|
|
std::fill(p, end - size, fill);
|
|
|
|
p = end;
|
|
|
|
}
|
|
|
|
return p - 1;
|
|
|
|
}
|
|
|
|
|
2014-09-29 15:48:16 +00:00
|
|
|
template <typename Char>
|
2013-01-08 17:56:05 +00:00
|
|
|
template <typename T, typename Spec>
|
2014-09-29 15:48:16 +00:00
|
|
|
void BasicWriter<Char>::write_int(T value, Spec spec) {
|
2014-06-07 15:57:55 +00:00
|
|
|
unsigned prefix_size = 0;
|
2014-02-19 20:43:55 +00:00
|
|
|
typedef typename internal::IntTraits<T>::MainType UnsignedType;
|
2013-01-08 17:56:05 +00:00
|
|
|
UnsignedType abs_value = value;
|
2014-06-07 15:57:55 +00:00
|
|
|
char prefix[4] = "";
|
2014-07-16 14:27:54 +00:00
|
|
|
if (internal::is_negative(value)) {
|
2014-06-07 15:57:55 +00:00
|
|
|
prefix[0] = '-';
|
|
|
|
++prefix_size;
|
2013-01-08 17:56:05 +00:00
|
|
|
abs_value = 0 - abs_value;
|
2014-07-25 15:29:06 +00:00
|
|
|
} else if (spec.flag(SIGN_FLAG)) {
|
|
|
|
prefix[0] = spec.flag(PLUS_FLAG) ? '+' : ' ';
|
2014-06-07 15:57:55 +00:00
|
|
|
++prefix_size;
|
2013-01-08 17:56:05 +00:00
|
|
|
}
|
2014-01-01 17:20:16 +00:00
|
|
|
switch (spec.type()) {
|
2013-01-08 17:56:05 +00:00
|
|
|
case 0: case 'd': {
|
2014-07-24 15:59:52 +00:00
|
|
|
unsigned num_digits = internal::count_digits(abs_value);
|
2014-07-28 15:41:50 +00:00
|
|
|
CharPtr p = prepare_int_buffer(
|
2014-06-07 15:57:55 +00:00
|
|
|
num_digits, spec, prefix, prefix_size) + 1 - num_digits;
|
2014-07-28 15:41:50 +00:00
|
|
|
internal::format_decimal(get(p), abs_value, num_digits);
|
2013-01-08 17:56:05 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
case 'x': case 'X': {
|
|
|
|
UnsignedType n = abs_value;
|
2014-07-25 15:29:06 +00:00
|
|
|
if (spec.flag(HASH_FLAG)) {
|
2014-06-07 15:57:55 +00:00
|
|
|
prefix[prefix_size++] = '0';
|
|
|
|
prefix[prefix_size++] = spec.type();
|
|
|
|
}
|
|
|
|
unsigned num_digits = 0;
|
2013-01-08 17:56:05 +00:00
|
|
|
do {
|
2014-06-07 15:57:55 +00:00
|
|
|
++num_digits;
|
2013-01-08 17:56:05 +00:00
|
|
|
} while ((n >>= 4) != 0);
|
2014-07-28 15:41:50 +00:00
|
|
|
Char *p = get(prepare_int_buffer(
|
2014-06-07 15:57:55 +00:00
|
|
|
num_digits, spec, prefix, prefix_size));
|
2013-01-08 17:56:05 +00:00
|
|
|
n = abs_value;
|
2014-01-01 17:20:16 +00:00
|
|
|
const char *digits = spec.type() == 'x' ?
|
2013-01-08 17:56:05 +00:00
|
|
|
"0123456789abcdef" : "0123456789ABCDEF";
|
|
|
|
do {
|
|
|
|
*p-- = digits[n & 0xf];
|
|
|
|
} while ((n >>= 4) != 0);
|
|
|
|
break;
|
|
|
|
}
|
2013-11-17 05:25:48 +00:00
|
|
|
case 'b': case 'B': {
|
2013-10-24 03:04:32 +00:00
|
|
|
UnsignedType n = abs_value;
|
2014-07-25 15:29:06 +00:00
|
|
|
if (spec.flag(HASH_FLAG)) {
|
2014-06-07 15:57:55 +00:00
|
|
|
prefix[prefix_size++] = '0';
|
|
|
|
prefix[prefix_size++] = spec.type();
|
|
|
|
}
|
|
|
|
unsigned num_digits = 0;
|
2013-10-24 03:04:32 +00:00
|
|
|
do {
|
2014-06-07 15:57:55 +00:00
|
|
|
++num_digits;
|
2013-10-24 03:04:32 +00:00
|
|
|
} while ((n >>= 1) != 0);
|
2014-07-28 15:41:50 +00:00
|
|
|
Char *p = get(prepare_int_buffer(num_digits, spec, prefix, prefix_size));
|
2013-10-24 03:04:32 +00:00
|
|
|
n = abs_value;
|
|
|
|
do {
|
2013-11-14 16:45:20 +00:00
|
|
|
*p-- = '0' + (n & 1);
|
2013-10-24 03:04:32 +00:00
|
|
|
} while ((n >>= 1) != 0);
|
|
|
|
break;
|
|
|
|
}
|
2013-01-08 17:56:05 +00:00
|
|
|
case 'o': {
|
|
|
|
UnsignedType n = abs_value;
|
2014-07-25 15:29:06 +00:00
|
|
|
if (spec.flag(HASH_FLAG))
|
2014-06-07 15:57:55 +00:00
|
|
|
prefix[prefix_size++] = '0';
|
|
|
|
unsigned num_digits = 0;
|
2013-01-08 17:56:05 +00:00
|
|
|
do {
|
2014-06-07 15:57:55 +00:00
|
|
|
++num_digits;
|
2013-01-08 17:56:05 +00:00
|
|
|
} while ((n >>= 3) != 0);
|
2014-07-28 15:41:50 +00:00
|
|
|
Char *p = get(prepare_int_buffer(num_digits, spec, prefix, prefix_size));
|
2013-01-08 17:56:05 +00:00
|
|
|
n = abs_value;
|
|
|
|
do {
|
|
|
|
*p-- = '0' + (n & 7);
|
|
|
|
} while ((n >>= 3) != 0);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
default:
|
2014-07-26 15:42:19 +00:00
|
|
|
internal::report_unknown_type(
|
2014-07-25 15:29:06 +00:00
|
|
|
spec.type(), spec.flag(CHAR_FLAG) ? "char" : "integer");
|
2013-01-08 17:56:05 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-09-29 15:48:16 +00:00
|
|
|
template <typename Char>
|
2014-09-19 14:51:42 +00:00
|
|
|
template <typename T>
|
2014-09-29 15:48:16 +00:00
|
|
|
void BasicWriter<Char>::write_double(
|
2014-09-19 14:51:42 +00:00
|
|
|
T value, const FormatSpec &spec) {
|
|
|
|
// Check type.
|
|
|
|
char type = spec.type();
|
|
|
|
bool upper = false;
|
|
|
|
switch (type) {
|
|
|
|
case 0:
|
|
|
|
type = 'g';
|
|
|
|
break;
|
|
|
|
case 'e': case 'f': case 'g': case 'a':
|
|
|
|
break;
|
|
|
|
case 'F':
|
|
|
|
#ifdef _MSC_VER
|
|
|
|
// MSVC's printf doesn't support 'F'.
|
|
|
|
type = 'f';
|
|
|
|
#endif
|
|
|
|
// Fall through.
|
|
|
|
case 'E': case 'G': case 'A':
|
|
|
|
upper = true;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
internal::report_unknown_type(type, "double");
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
char sign = 0;
|
|
|
|
// Use getsign instead of value < 0 because the latter is always
|
|
|
|
// false for NaN.
|
|
|
|
if (internal::getsign(static_cast<double>(value))) {
|
|
|
|
sign = '-';
|
|
|
|
value = -value;
|
|
|
|
} else if (spec.flag(SIGN_FLAG)) {
|
|
|
|
sign = spec.flag(PLUS_FLAG) ? '+' : ' ';
|
|
|
|
}
|
|
|
|
|
|
|
|
if (value != value) {
|
|
|
|
// Format NaN ourselves because sprintf's output is not consistent
|
|
|
|
// across platforms.
|
2014-12-10 15:24:05 +00:00
|
|
|
std::size_t nan_size = 4;
|
2014-09-19 14:51:42 +00:00
|
|
|
const char *nan = upper ? " NAN" : " nan";
|
|
|
|
if (!sign) {
|
2014-12-10 15:24:05 +00:00
|
|
|
--nan_size;
|
2014-09-19 14:51:42 +00:00
|
|
|
++nan;
|
|
|
|
}
|
2014-12-10 15:24:05 +00:00
|
|
|
CharPtr out = write_str(nan, nan_size, spec);
|
2014-09-19 14:51:42 +00:00
|
|
|
if (sign)
|
|
|
|
*out = sign;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (internal::isinfinity(value)) {
|
|
|
|
// Format infinity ourselves because sprintf's output is not consistent
|
|
|
|
// across platforms.
|
2014-12-10 15:24:05 +00:00
|
|
|
std::size_t inf_size = 4;
|
2014-09-19 14:51:42 +00:00
|
|
|
const char *inf = upper ? " INF" : " inf";
|
|
|
|
if (!sign) {
|
2014-12-10 15:24:05 +00:00
|
|
|
--inf_size;
|
2014-09-19 14:51:42 +00:00
|
|
|
++inf;
|
|
|
|
}
|
2014-12-10 15:24:05 +00:00
|
|
|
CharPtr out = write_str(inf, inf_size, spec);
|
2014-09-19 14:51:42 +00:00
|
|
|
if (sign)
|
|
|
|
*out = sign;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
std::size_t offset = buffer_.size();
|
|
|
|
unsigned width = spec.width();
|
|
|
|
if (sign) {
|
|
|
|
buffer_.reserve(buffer_.size() + (std::max)(width, 1u));
|
|
|
|
if (width > 0)
|
|
|
|
--width;
|
|
|
|
++offset;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Build format string.
|
|
|
|
enum { MAX_FORMAT_SIZE = 10}; // longest format: %#-*.*Lg
|
|
|
|
Char format[MAX_FORMAT_SIZE];
|
|
|
|
Char *format_ptr = format;
|
|
|
|
*format_ptr++ = '%';
|
|
|
|
unsigned width_for_sprintf = width;
|
|
|
|
if (spec.flag(HASH_FLAG))
|
|
|
|
*format_ptr++ = '#';
|
|
|
|
if (spec.align() == ALIGN_CENTER) {
|
|
|
|
width_for_sprintf = 0;
|
|
|
|
} else {
|
|
|
|
if (spec.align() == ALIGN_LEFT)
|
|
|
|
*format_ptr++ = '-';
|
|
|
|
if (width != 0)
|
|
|
|
*format_ptr++ = '*';
|
|
|
|
}
|
|
|
|
if (spec.precision() >= 0) {
|
|
|
|
*format_ptr++ = '.';
|
|
|
|
*format_ptr++ = '*';
|
|
|
|
}
|
2014-11-25 23:01:09 +00:00
|
|
|
|
2014-12-03 14:33:31 +00:00
|
|
|
append_float_length(format_ptr, value);
|
2014-09-19 14:51:42 +00:00
|
|
|
*format_ptr++ = type;
|
|
|
|
*format_ptr = '\0';
|
|
|
|
|
|
|
|
// Format using snprintf.
|
2015-06-17 14:21:16 +00:00
|
|
|
Char fill = internal::CharTraits<Char>::cast(spec.fill());
|
2014-09-19 14:51:42 +00:00
|
|
|
for (;;) {
|
2014-12-10 15:24:05 +00:00
|
|
|
std::size_t buffer_size = buffer_.capacity() - offset;
|
2014-09-19 14:51:42 +00:00
|
|
|
#if _MSC_VER
|
|
|
|
// MSVC's vsnprintf_s doesn't work with zero size, so reserve
|
|
|
|
// space for at least one extra character to make the size non-zero.
|
|
|
|
// Note that the buffer's capacity will increase by more than 1.
|
2014-12-10 15:24:05 +00:00
|
|
|
if (buffer_size == 0) {
|
2014-09-19 14:51:42 +00:00
|
|
|
buffer_.reserve(offset + 1);
|
2014-12-10 15:24:05 +00:00
|
|
|
buffer_size = buffer_.capacity() - offset;
|
2014-09-19 14:51:42 +00:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
Char *start = &buffer_[offset];
|
|
|
|
int n = internal::CharTraits<Char>::format_float(
|
2014-12-10 15:24:05 +00:00
|
|
|
start, buffer_size, format, width_for_sprintf, spec.precision(), value);
|
2014-09-19 14:51:42 +00:00
|
|
|
if (n >= 0 && offset + n < buffer_.capacity()) {
|
|
|
|
if (sign) {
|
|
|
|
if ((spec.align() != ALIGN_RIGHT && spec.align() != ALIGN_DEFAULT) ||
|
|
|
|
*start != ' ') {
|
|
|
|
*(start - 1) = sign;
|
|
|
|
sign = 0;
|
|
|
|
} else {
|
|
|
|
*(start - 1) = fill;
|
|
|
|
}
|
|
|
|
++n;
|
|
|
|
}
|
|
|
|
if (spec.align() == ALIGN_CENTER &&
|
|
|
|
spec.width() > static_cast<unsigned>(n)) {
|
2014-12-10 15:24:05 +00:00
|
|
|
width = spec.width();
|
2014-09-19 14:51:42 +00:00
|
|
|
CharPtr p = grow_buffer(width);
|
|
|
|
std::copy(p, p + n, p + (width - n) / 2);
|
|
|
|
fill_padding(p, spec.width(), n, fill);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (spec.fill() != ' ' || sign) {
|
|
|
|
while (*start == ' ')
|
|
|
|
*start++ = fill;
|
|
|
|
if (sign)
|
|
|
|
*(start - 1) = sign;
|
|
|
|
}
|
|
|
|
grow_buffer(n);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
// If n is negative we ask to increase the capacity by at least 1,
|
|
|
|
// but as std::vector, the buffer grows exponentially.
|
|
|
|
buffer_.reserve(n >= 0 ? offset + n + 1 : buffer_.capacity() + 1);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-10-01 15:32:01 +00:00
|
|
|
/**
|
|
|
|
\rst
|
2015-03-02 02:08:24 +00:00
|
|
|
This class template provides operations for formatting and writing data
|
|
|
|
into a character stream. The output is stored in a memory buffer that grows
|
2014-10-01 15:32:01 +00:00
|
|
|
dynamically.
|
|
|
|
|
|
|
|
You can use one of the following typedefs for common character types
|
|
|
|
and the standard allocator:
|
|
|
|
|
2015-03-02 02:08:24 +00:00
|
|
|
+---------------+-----------------------------------------------------+
|
|
|
|
| Type | Definition |
|
|
|
|
+===============+=====================================================+
|
|
|
|
| MemoryWriter | BasicMemoryWriter<char, std::allocator<char>> |
|
|
|
|
+---------------+-----------------------------------------------------+
|
|
|
|
| WMemoryWriter | BasicMemoryWriter<wchar_t, std::allocator<wchar_t>> |
|
|
|
|
+---------------+-----------------------------------------------------+
|
2014-10-01 15:32:01 +00:00
|
|
|
|
|
|
|
**Example**::
|
|
|
|
|
|
|
|
MemoryWriter out;
|
|
|
|
out << "The answer is " << 42 << "\n";
|
|
|
|
out.write("({:+f}, {:+f})", -3.14, 3.14);
|
|
|
|
|
|
|
|
This will write the following output to the ``out`` object:
|
|
|
|
|
|
|
|
.. code-block:: none
|
|
|
|
|
|
|
|
The answer is 42
|
|
|
|
(-3.140000, +3.140000)
|
|
|
|
|
|
|
|
The output can be converted to an ``std::string`` with ``out.str()`` or
|
|
|
|
accessed as a C string with ``out.c_str()``.
|
|
|
|
\endrst
|
|
|
|
*/
|
2014-09-29 15:48:16 +00:00
|
|
|
template <typename Char, typename Allocator = std::allocator<Char> >
|
|
|
|
class BasicMemoryWriter : public BasicWriter<Char> {
|
|
|
|
private:
|
|
|
|
internal::MemoryBuffer<Char, internal::INLINE_BUFFER_SIZE, Allocator> buffer_;
|
|
|
|
|
|
|
|
public:
|
|
|
|
explicit BasicMemoryWriter(const Allocator& alloc = Allocator())
|
|
|
|
: BasicWriter<Char>(buffer_), buffer_(alloc) {}
|
|
|
|
|
|
|
|
#if FMT_USE_RVALUE_REFERENCES
|
|
|
|
/**
|
2015-03-02 04:58:45 +00:00
|
|
|
\rst
|
2014-12-18 16:36:53 +00:00
|
|
|
Constructs a :class:`fmt::BasicMemoryWriter` object moving the content
|
|
|
|
of the other object to it.
|
2015-03-02 04:58:45 +00:00
|
|
|
\endrst
|
2014-09-29 15:48:16 +00:00
|
|
|
*/
|
|
|
|
BasicMemoryWriter(BasicMemoryWriter &&other)
|
|
|
|
: BasicWriter<Char>(buffer_), buffer_(std::move(other.buffer_)) {
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2015-03-02 04:58:45 +00:00
|
|
|
\rst
|
2014-09-29 15:48:16 +00:00
|
|
|
Moves the content of the other ``BasicMemoryWriter`` object to this one.
|
2015-03-02 04:58:45 +00:00
|
|
|
\endrst
|
2014-09-29 15:48:16 +00:00
|
|
|
*/
|
|
|
|
BasicMemoryWriter &operator=(BasicMemoryWriter &&other) {
|
|
|
|
buffer_ = std::move(other.buffer_);
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
};
|
|
|
|
|
|
|
|
typedef BasicMemoryWriter<char> MemoryWriter;
|
|
|
|
typedef BasicMemoryWriter<wchar_t> WMemoryWriter;
|
|
|
|
|
2015-03-02 02:08:24 +00:00
|
|
|
/**
|
|
|
|
\rst
|
|
|
|
This class template provides operations for formatting and writing data
|
|
|
|
into a fixed-size array. For writing into a dynamically growing buffer
|
|
|
|
use :class:`fmt::BasicMemoryWriter`.
|
|
|
|
|
2015-03-02 04:58:45 +00:00
|
|
|
Any write method will throw ``std::runtime_error`` if the output doesn't fit
|
2015-03-02 02:08:24 +00:00
|
|
|
into the array.
|
|
|
|
|
|
|
|
You can use one of the following typedefs for common character types:
|
|
|
|
|
|
|
|
+--------------+---------------------------+
|
|
|
|
| Type | Definition |
|
|
|
|
+==============+===========================+
|
|
|
|
| ArrayWriter | BasicArrayWriter<char> |
|
|
|
|
+--------------+---------------------------+
|
|
|
|
| WArrayWriter | BasicArrayWriter<wchar_t> |
|
|
|
|
+--------------+---------------------------+
|
|
|
|
\endrst
|
|
|
|
*/
|
|
|
|
template <typename Char>
|
|
|
|
class BasicArrayWriter : public BasicWriter<Char> {
|
|
|
|
private:
|
|
|
|
internal::FixedBuffer<Char> buffer_;
|
|
|
|
|
|
|
|
public:
|
|
|
|
/**
|
|
|
|
\rst
|
|
|
|
Constructs a :class:`fmt::BasicArrayWriter` object for *array* of the
|
|
|
|
given size.
|
|
|
|
\endrst
|
|
|
|
*/
|
|
|
|
BasicArrayWriter(Char *array, std::size_t size)
|
|
|
|
: BasicWriter<Char>(buffer_), buffer_(array, size) {}
|
|
|
|
|
2015-06-04 01:21:01 +00:00
|
|
|
/**
|
2015-03-02 02:08:24 +00:00
|
|
|
\rst
|
|
|
|
Constructs a :class:`fmt::BasicArrayWriter` object for *array* of the
|
|
|
|
size known at compile time.
|
|
|
|
\endrst
|
|
|
|
*/
|
|
|
|
template <std::size_t SIZE>
|
|
|
|
explicit BasicArrayWriter(Char (&array)[SIZE])
|
|
|
|
: BasicWriter<Char>(buffer_), buffer_(array, SIZE) {}
|
|
|
|
};
|
|
|
|
|
|
|
|
typedef BasicArrayWriter<char> ArrayWriter;
|
|
|
|
typedef BasicArrayWriter<wchar_t> WArrayWriter;
|
|
|
|
|
2014-07-08 23:20:33 +00:00
|
|
|
// Formats a value.
|
2013-01-27 00:07:28 +00:00
|
|
|
template <typename Char, typename T>
|
2014-08-29 14:23:54 +00:00
|
|
|
void format(BasicFormatter<Char> &f, const Char *&format_str, const T &value) {
|
2013-01-27 00:07:28 +00:00
|
|
|
std::basic_ostringstream<Char> os;
|
2013-01-13 15:50:28 +00:00
|
|
|
os << value;
|
2014-09-25 19:15:16 +00:00
|
|
|
std::basic_string<Char> str = os.str();
|
2015-03-27 14:36:26 +00:00
|
|
|
internal::Arg arg = internal::MakeValue<Char>(str);
|
2015-02-25 00:44:01 +00:00
|
|
|
arg.type = static_cast<internal::Arg::Type>(
|
2015-03-27 14:36:26 +00:00
|
|
|
internal::MakeValue<Char>::type(str));
|
2014-09-23 14:59:43 +00:00
|
|
|
format_str = f.format(format_str, arg);
|
2013-01-13 15:50:28 +00:00
|
|
|
}
|
2013-01-08 17:56:05 +00:00
|
|
|
|
2014-05-03 16:48:54 +00:00
|
|
|
// Reports a system error without throwing an exception.
|
|
|
|
// Can be used to report errors from destructors.
|
2015-02-14 01:58:29 +00:00
|
|
|
void report_system_error(int error_code, StringRef message) FMT_NOEXCEPT;
|
2014-05-03 16:48:54 +00:00
|
|
|
|
2015-06-12 14:15:57 +00:00
|
|
|
#if FMT_USE_WINDOWS_H
|
2014-05-03 16:48:54 +00:00
|
|
|
|
2015-02-07 17:46:42 +00:00
|
|
|
/** A Windows error. */
|
2014-06-30 21:26:29 +00:00
|
|
|
class WindowsError : public SystemError {
|
|
|
|
private:
|
2015-06-26 16:23:11 +00:00
|
|
|
void init(int error_code, CStringRef format_str, ArgList args);
|
2014-05-14 14:05:09 +00:00
|
|
|
|
2014-06-30 21:26:29 +00:00
|
|
|
public:
|
|
|
|
/**
|
|
|
|
\rst
|
2014-12-18 16:36:53 +00:00
|
|
|
Constructs a :class:`fmt::WindowsError` object with the description
|
2015-02-06 16:43:02 +00:00
|
|
|
of the form
|
|
|
|
|
|
|
|
.. parsed-literal::
|
|
|
|
*<message>*: *<system-message>*
|
2015-02-12 20:46:28 +00:00
|
|
|
|
2015-02-25 00:44:01 +00:00
|
|
|
where *<message>* is the formatted message and *<system-message>* is the
|
|
|
|
system message corresponding to the error code.
|
2014-06-30 21:26:29 +00:00
|
|
|
*error_code* is a Windows error code as given by ``GetLastError``.
|
2015-02-07 17:46:42 +00:00
|
|
|
If *error_code* is not a valid error code such as -1, the system message
|
|
|
|
will look like "error -1".
|
|
|
|
|
2015-02-06 16:43:02 +00:00
|
|
|
**Example**::
|
|
|
|
|
2015-02-06 16:45:43 +00:00
|
|
|
// This throws a WindowsError with the description
|
2015-02-06 16:43:02 +00:00
|
|
|
// cannot open file 'madeup': The system cannot find the file specified.
|
|
|
|
// or similar (system message may vary).
|
|
|
|
const char *filename = "madeup";
|
|
|
|
LPOFSTRUCT of = LPOFSTRUCT();
|
|
|
|
HFILE file = OpenFile(filename, &of, OF_READ);
|
2015-02-25 00:44:01 +00:00
|
|
|
if (file == HFILE_ERROR) {
|
|
|
|
throw fmt::WindowsError(GetLastError(),
|
|
|
|
"cannot open file '{}'", filename);
|
|
|
|
}
|
2014-06-30 21:26:29 +00:00
|
|
|
\endrst
|
|
|
|
*/
|
2015-06-26 16:23:11 +00:00
|
|
|
WindowsError(int error_code, CStringRef message) {
|
2014-06-30 21:26:29 +00:00
|
|
|
init(error_code, message, ArgList());
|
|
|
|
}
|
2015-06-26 16:23:11 +00:00
|
|
|
FMT_VARIADIC_CTOR(WindowsError, init, int, CStringRef)
|
2014-06-30 21:26:29 +00:00
|
|
|
};
|
|
|
|
|
2014-05-03 16:48:54 +00:00
|
|
|
// Reports a Windows error without throwing an exception.
|
|
|
|
// Can be used to report errors from destructors.
|
2015-02-14 01:58:29 +00:00
|
|
|
void report_windows_error(int error_code, StringRef message) FMT_NOEXCEPT;
|
2014-05-03 16:48:54 +00:00
|
|
|
|
|
|
|
#endif
|
|
|
|
|
2014-04-28 15:59:29 +00:00
|
|
|
enum Color { BLACK, RED, GREEN, YELLOW, BLUE, MAGENTA, CYAN, WHITE };
|
|
|
|
|
|
|
|
/**
|
|
|
|
Formats a string and prints it to stdout using ANSI escape sequences
|
|
|
|
to specify color (experimental).
|
|
|
|
Example:
|
|
|
|
PrintColored(fmt::RED, "Elapsed time: {0:.2f} seconds") << 1.23;
|
|
|
|
*/
|
2015-06-26 14:43:54 +00:00
|
|
|
void print_colored(Color c, CStringRef format, ArgList args);
|
2014-04-28 15:59:29 +00:00
|
|
|
|
2014-05-13 15:55:13 +00:00
|
|
|
/**
|
|
|
|
\rst
|
2014-08-21 15:49:13 +00:00
|
|
|
Formats arguments and returns the result as a string.
|
2014-05-13 15:55:13 +00:00
|
|
|
|
|
|
|
**Example**::
|
|
|
|
|
2014-06-29 18:51:10 +00:00
|
|
|
std::string message = format("The answer is {}", 42);
|
2014-05-13 15:55:13 +00:00
|
|
|
\endrst
|
2014-06-28 21:48:42 +00:00
|
|
|
*/
|
2015-06-26 14:43:54 +00:00
|
|
|
inline std::string format(CStringRef format_str, ArgList args) {
|
2014-09-29 15:48:16 +00:00
|
|
|
MemoryWriter w;
|
2014-06-29 18:51:10 +00:00
|
|
|
w.write(format_str, args);
|
|
|
|
return w.str();
|
2014-06-28 21:48:42 +00:00
|
|
|
}
|
|
|
|
|
2015-06-26 14:43:54 +00:00
|
|
|
inline std::wstring format(WCStringRef format_str, ArgList args) {
|
2014-09-29 15:48:16 +00:00
|
|
|
WMemoryWriter w;
|
2014-07-29 13:26:44 +00:00
|
|
|
w.write(format_str, args);
|
2014-06-29 18:51:10 +00:00
|
|
|
return w.str();
|
2014-06-28 22:58:02 +00:00
|
|
|
}
|
|
|
|
|
2014-06-29 18:51:10 +00:00
|
|
|
/**
|
|
|
|
\rst
|
2014-08-21 15:49:13 +00:00
|
|
|
Prints formatted data to the file *f*.
|
2014-06-29 18:51:10 +00:00
|
|
|
|
|
|
|
**Example**::
|
|
|
|
|
2014-08-21 15:49:13 +00:00
|
|
|
print(stderr, "Don't {}!", "panic");
|
2014-06-29 18:51:10 +00:00
|
|
|
\endrst
|
|
|
|
*/
|
2015-06-26 14:43:54 +00:00
|
|
|
void print(std::FILE *f, CStringRef format_str, ArgList args);
|
2014-06-29 18:51:10 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
\rst
|
2014-08-21 15:49:13 +00:00
|
|
|
Prints formatted data to ``stdout``.
|
2014-06-29 18:51:10 +00:00
|
|
|
|
|
|
|
**Example**::
|
|
|
|
|
2014-08-21 15:49:13 +00:00
|
|
|
print("Elapsed time: {0:.2f} seconds", 1.23);
|
2014-06-29 18:51:10 +00:00
|
|
|
\endrst
|
|
|
|
*/
|
2015-06-26 14:43:54 +00:00
|
|
|
void print(CStringRef format_str, ArgList args);
|
2014-06-29 04:56:40 +00:00
|
|
|
|
2014-07-09 13:56:36 +00:00
|
|
|
/**
|
|
|
|
\rst
|
2014-08-21 15:49:13 +00:00
|
|
|
Prints formatted data to the stream *os*.
|
2014-07-09 13:56:36 +00:00
|
|
|
|
|
|
|
**Example**::
|
|
|
|
|
|
|
|
print(cerr, "Don't {}!", "panic");
|
|
|
|
\endrst
|
|
|
|
*/
|
2015-06-26 14:43:54 +00:00
|
|
|
void print(std::ostream &os, CStringRef format_str, ArgList args);
|
2014-07-09 13:56:36 +00:00
|
|
|
|
2014-07-01 23:23:50 +00:00
|
|
|
template <typename Char>
|
2015-06-26 14:43:54 +00:00
|
|
|
void printf(BasicWriter<Char> &w, BasicCStringRef<Char> format, ArgList args) {
|
2015-07-28 15:09:29 +00:00
|
|
|
internal::PrintfFormatter<Char>(args).format(w, format);
|
2014-07-01 23:23:50 +00:00
|
|
|
}
|
|
|
|
|
2014-08-21 15:49:13 +00:00
|
|
|
/**
|
|
|
|
\rst
|
|
|
|
Formats arguments and returns the result as a string.
|
|
|
|
|
|
|
|
**Example**::
|
|
|
|
|
|
|
|
std::string message = fmt::sprintf("The answer is %d", 42);
|
|
|
|
\endrst
|
|
|
|
*/
|
2015-06-26 14:43:54 +00:00
|
|
|
inline std::string sprintf(CStringRef format, ArgList args) {
|
2014-09-29 15:48:16 +00:00
|
|
|
MemoryWriter w;
|
2014-06-30 02:52:26 +00:00
|
|
|
printf(w, format, args);
|
2014-06-29 18:51:10 +00:00
|
|
|
return w.str();
|
2014-06-29 04:56:40 +00:00
|
|
|
}
|
|
|
|
|
2014-08-21 15:49:13 +00:00
|
|
|
/**
|
|
|
|
\rst
|
|
|
|
Prints formatted data to the file *f*.
|
|
|
|
|
|
|
|
**Example**::
|
|
|
|
|
|
|
|
fmt::fprintf(stderr, "Don't %s!", "panic");
|
|
|
|
\endrst
|
|
|
|
*/
|
2015-06-26 14:43:54 +00:00
|
|
|
int fprintf(std::FILE *f, CStringRef format, ArgList args);
|
2014-08-21 15:49:13 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
\rst
|
|
|
|
Prints formatted data to ``stdout``.
|
|
|
|
|
|
|
|
**Example**::
|
|
|
|
|
|
|
|
fmt::printf("Elapsed time: %.2f seconds", 1.23);
|
|
|
|
\endrst
|
|
|
|
*/
|
2015-06-26 14:43:54 +00:00
|
|
|
inline int printf(CStringRef format, ArgList args) {
|
2014-08-21 15:49:13 +00:00
|
|
|
return fprintf(stdout, format, args);
|
|
|
|
}
|
2014-06-29 02:44:39 +00:00
|
|
|
|
2013-09-09 13:51:03 +00:00
|
|
|
/**
|
|
|
|
Fast integer formatter.
|
|
|
|
*/
|
|
|
|
class FormatInt {
|
|
|
|
private:
|
|
|
|
// Buffer should be large enough to hold all digits (digits10 + 1),
|
|
|
|
// a sign and a null character.
|
2014-02-15 18:02:02 +00:00
|
|
|
enum {BUFFER_SIZE = std::numeric_limits<ULongLong>::digits10 + 3};
|
2014-02-15 17:24:31 +00:00
|
|
|
mutable char buffer_[BUFFER_SIZE];
|
2013-09-09 13:51:03 +00:00
|
|
|
char *str_;
|
2013-11-21 17:11:58 +00:00
|
|
|
|
2013-09-09 13:51:03 +00:00
|
|
|
// Formats value in reverse and returns the number of digits.
|
2014-07-27 04:31:40 +00:00
|
|
|
char *format_decimal(ULongLong value) {
|
2014-02-15 17:24:31 +00:00
|
|
|
char *buffer_end = buffer_ + BUFFER_SIZE - 1;
|
2013-09-09 13:51:03 +00:00
|
|
|
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 = (value % 100) * 2;
|
|
|
|
value /= 100;
|
2014-11-29 14:58:00 +00:00
|
|
|
*--buffer_end = internal::Data::DIGITS[index + 1];
|
|
|
|
*--buffer_end = internal::Data::DIGITS[index];
|
2013-09-09 13:51:03 +00:00
|
|
|
}
|
|
|
|
if (value < 10) {
|
|
|
|
*--buffer_end = static_cast<char>('0' + value);
|
|
|
|
return buffer_end;
|
|
|
|
}
|
|
|
|
unsigned index = static_cast<unsigned>(value * 2);
|
2014-11-29 14:58:00 +00:00
|
|
|
*--buffer_end = internal::Data::DIGITS[index + 1];
|
|
|
|
*--buffer_end = internal::Data::DIGITS[index];
|
2013-09-09 13:51:03 +00:00
|
|
|
return buffer_end;
|
|
|
|
}
|
2014-04-28 15:59:29 +00:00
|
|
|
|
2014-02-15 17:58:33 +00:00
|
|
|
void FormatSigned(LongLong value) {
|
2014-08-15 15:40:03 +00:00
|
|
|
ULongLong abs_value = static_cast<ULongLong>(value);
|
2013-09-09 13:51:03 +00:00
|
|
|
bool negative = value < 0;
|
|
|
|
if (negative)
|
2014-08-15 15:40:03 +00:00
|
|
|
abs_value = 0 - abs_value;
|
2014-07-27 04:31:40 +00:00
|
|
|
str_ = format_decimal(abs_value);
|
2013-09-09 13:51:03 +00:00
|
|
|
if (negative)
|
|
|
|
*--str_ = '-';
|
|
|
|
}
|
2014-01-30 16:02:06 +00:00
|
|
|
|
|
|
|
public:
|
|
|
|
explicit FormatInt(int value) { FormatSigned(value); }
|
2014-02-13 17:59:49 +00:00
|
|
|
explicit FormatInt(long value) { FormatSigned(value); }
|
2014-02-15 17:58:33 +00:00
|
|
|
explicit FormatInt(LongLong value) { FormatSigned(value); }
|
2014-07-27 04:31:40 +00:00
|
|
|
explicit FormatInt(unsigned value) : str_(format_decimal(value)) {}
|
|
|
|
explicit FormatInt(unsigned long value) : str_(format_decimal(value)) {}
|
|
|
|
explicit FormatInt(ULongLong value) : str_(format_decimal(value)) {}
|
2013-09-09 13:51:03 +00:00
|
|
|
|
2014-02-15 17:39:06 +00:00
|
|
|
/**
|
|
|
|
Returns the number of characters written to the output buffer.
|
|
|
|
*/
|
|
|
|
std::size_t size() const { return buffer_ - str_ + BUFFER_SIZE - 1; }
|
|
|
|
|
|
|
|
/**
|
|
|
|
Returns a pointer to the output buffer content. No terminating null
|
|
|
|
character is appended.
|
|
|
|
*/
|
|
|
|
const char *data() const { return str_; }
|
|
|
|
|
|
|
|
/**
|
|
|
|
Returns a pointer to the output buffer content with terminating null
|
|
|
|
character appended.
|
|
|
|
*/
|
2014-02-15 17:24:31 +00:00
|
|
|
const char *c_str() const {
|
|
|
|
buffer_[BUFFER_SIZE - 1] = '\0';
|
|
|
|
return str_;
|
|
|
|
}
|
2014-02-15 17:39:06 +00:00
|
|
|
|
|
|
|
/**
|
2015-05-22 14:08:16 +00:00
|
|
|
\rst
|
|
|
|
Returns the content of the output buffer as an ``std::string``.
|
|
|
|
\endrst
|
2014-02-15 17:39:06 +00:00
|
|
|
*/
|
2014-02-15 17:24:31 +00:00
|
|
|
std::string str() const { return std::string(str_, size()); }
|
2013-09-09 13:51:03 +00:00
|
|
|
};
|
|
|
|
|
2014-02-14 18:36:17 +00:00
|
|
|
// 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>
|
2014-07-29 15:45:29 +00:00
|
|
|
inline void format_decimal(char *&buffer, T value) {
|
2014-02-20 15:04:54 +00:00
|
|
|
typename internal::IntTraits<T>::MainType abs_value = value;
|
2014-07-16 14:27:54 +00:00
|
|
|
if (internal::is_negative(value)) {
|
2014-02-14 18:36:17 +00:00
|
|
|
*buffer++ = '-';
|
|
|
|
abs_value = 0 - abs_value;
|
|
|
|
}
|
2014-02-21 05:05:46 +00:00
|
|
|
if (abs_value < 100) {
|
|
|
|
if (abs_value < 10) {
|
|
|
|
*buffer++ = static_cast<char>('0' + abs_value);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
unsigned index = static_cast<unsigned>(abs_value * 2);
|
2014-11-29 14:58:00 +00:00
|
|
|
*buffer++ = internal::Data::DIGITS[index];
|
|
|
|
*buffer++ = internal::Data::DIGITS[index + 1];
|
2014-02-21 05:05:46 +00:00
|
|
|
return;
|
|
|
|
}
|
2014-07-24 15:59:52 +00:00
|
|
|
unsigned num_digits = internal::count_digits(abs_value);
|
2014-07-27 04:31:40 +00:00
|
|
|
internal::format_decimal(buffer, abs_value, num_digits);
|
2014-02-14 18:36:17 +00:00
|
|
|
buffer += num_digits;
|
|
|
|
}
|
2015-06-10 01:32:59 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
\rst
|
|
|
|
Returns a named argument for formatting functions.
|
|
|
|
|
|
|
|
**Example**::
|
|
|
|
|
|
|
|
print("Elapsed time: {s:.2f} seconds", arg("s", 1.23));
|
|
|
|
|
|
|
|
\endrst
|
|
|
|
*/
|
|
|
|
template <typename T>
|
|
|
|
inline internal::NamedArg<char> arg(StringRef name, const T &arg) {
|
|
|
|
return internal::NamedArg<char>(name, arg);
|
|
|
|
}
|
|
|
|
|
|
|
|
template <typename T>
|
|
|
|
inline internal::NamedArg<wchar_t> arg(WStringRef name, const T &arg) {
|
|
|
|
return internal::NamedArg<wchar_t>(name, arg);
|
|
|
|
}
|
|
|
|
|
2015-06-11 14:19:00 +00:00
|
|
|
// The following two functions are deleted intentionally to disable
|
|
|
|
// nested named arguments as in ``format("{}", arg("a", arg("b", 42)))``.
|
2015-06-10 01:32:59 +00:00
|
|
|
template <typename Char>
|
2015-06-11 14:19:00 +00:00
|
|
|
void arg(StringRef, const internal::NamedArg<Char>&) FMT_DELETED_OR_UNDEFINED;
|
2015-06-10 01:32:59 +00:00
|
|
|
template <typename Char>
|
2015-06-11 14:19:00 +00:00
|
|
|
void arg(WStringRef, const internal::NamedArg<Char>&) FMT_DELETED_OR_UNDEFINED;
|
2012-12-07 16:31:09 +00:00
|
|
|
}
|
|
|
|
|
2014-06-24 20:01:44 +00:00
|
|
|
#if FMT_GCC_VERSION
|
|
|
|
// Use the system_header pragma to suppress warnings about variadic macros
|
2014-07-26 16:45:03 +00:00
|
|
|
// because suppressing -Wvariadic-macros with the diagnostic pragma doesn't
|
|
|
|
// work. It is used at the end because we want to suppress as little warnings
|
|
|
|
// as possible.
|
2014-06-24 20:01:44 +00:00
|
|
|
# pragma GCC system_header
|
|
|
|
#endif
|
|
|
|
|
2014-06-28 18:36:49 +00:00
|
|
|
// This is used to work around VC++ bugs in handling variadic macros.
|
2014-06-24 18:09:07 +00:00
|
|
|
#define FMT_EXPAND(args) args
|
2014-06-28 18:30:15 +00:00
|
|
|
|
|
|
|
// Returns the number of arguments.
|
|
|
|
// Based on https://groups.google.com/forum/#!topic/comp.std.c/d-6Mj5Lko_s.
|
|
|
|
#define FMT_NARG(...) FMT_NARG_(__VA_ARGS__, FMT_RSEQ_N())
|
2014-06-28 18:36:49 +00:00
|
|
|
#define FMT_NARG_(...) FMT_EXPAND(FMT_ARG_N(__VA_ARGS__))
|
2014-06-28 18:30:15 +00:00
|
|
|
#define FMT_ARG_N(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, N, ...) N
|
|
|
|
#define FMT_RSEQ_N() 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0
|
2014-06-24 17:14:50 +00:00
|
|
|
|
2014-06-28 18:43:07 +00:00
|
|
|
#define FMT_CONCAT(a, b) a##b
|
2014-06-28 19:49:51 +00:00
|
|
|
#define FMT_FOR_EACH_(N, f, ...) \
|
|
|
|
FMT_EXPAND(FMT_CONCAT(FMT_FOR_EACH, N)(f, __VA_ARGS__))
|
2014-06-28 18:07:43 +00:00
|
|
|
#define FMT_FOR_EACH(f, ...) \
|
2014-06-28 18:30:15 +00:00
|
|
|
FMT_EXPAND(FMT_FOR_EACH_(FMT_NARG(__VA_ARGS__), f, __VA_ARGS__))
|
2014-06-24 17:14:50 +00:00
|
|
|
|
|
|
|
#define FMT_ADD_ARG_NAME(type, index) type arg##index
|
|
|
|
#define FMT_GET_ARG_NAME(type, index) arg##index
|
2014-06-28 20:31:44 +00:00
|
|
|
|
|
|
|
#if FMT_USE_VARIADIC_TEMPLATES
|
2014-07-01 23:23:50 +00:00
|
|
|
# define FMT_VARIADIC_(Char, ReturnType, func, call, ...) \
|
2014-09-24 14:48:45 +00:00
|
|
|
template <typename... Args> \
|
2014-06-28 22:58:02 +00:00
|
|
|
ReturnType func(FMT_FOR_EACH(FMT_ADD_ARG_NAME, __VA_ARGS__), \
|
2014-06-28 20:31:44 +00:00
|
|
|
const Args & ... args) { \
|
2015-05-05 14:23:32 +00:00
|
|
|
typename fmt::internal::ArgArray<sizeof...(Args)>::Type array; \
|
2015-03-24 15:55:40 +00:00
|
|
|
call(FMT_FOR_EACH(FMT_GET_ARG_NAME, __VA_ARGS__), \
|
2015-05-05 14:23:32 +00:00
|
|
|
fmt::internal::make_arg_list<Char>(array, args...)); \
|
2014-06-28 20:31:44 +00:00
|
|
|
}
|
|
|
|
#else
|
2014-06-28 18:07:43 +00:00
|
|
|
// Defines a wrapper for a function taking __VA_ARGS__ arguments
|
|
|
|
// and n additional arguments of arbitrary types.
|
2014-07-01 23:23:50 +00:00
|
|
|
# define FMT_WRAP(Char, ReturnType, func, call, n, ...) \
|
2014-06-28 18:07:43 +00:00
|
|
|
template <FMT_GEN(n, FMT_MAKE_TEMPLATE_ARG)> \
|
2014-06-28 22:58:02 +00:00
|
|
|
inline ReturnType func(FMT_FOR_EACH(FMT_ADD_ARG_NAME, __VA_ARGS__), \
|
2014-06-28 19:14:43 +00:00
|
|
|
FMT_GEN(n, FMT_MAKE_ARG)) { \
|
2015-05-05 14:23:32 +00:00
|
|
|
fmt::internal::ArgArray<n>::Type arr = {FMT_GEN(n, FMT_MAKE_REF_##Char)}; \
|
2014-09-23 14:59:43 +00:00
|
|
|
call(FMT_FOR_EACH(FMT_GET_ARG_NAME, __VA_ARGS__), fmt::ArgList( \
|
2015-05-05 14:23:32 +00:00
|
|
|
fmt::internal::make_type(FMT_GEN(n, FMT_MAKE_REF2)), arr)); \
|
2014-06-28 20:31:44 +00:00
|
|
|
}
|
|
|
|
|
2014-07-01 23:23:50 +00:00
|
|
|
# define FMT_VARIADIC_(Char, ReturnType, func, call, ...) \
|
2014-06-28 22:58:02 +00:00
|
|
|
inline ReturnType func(FMT_FOR_EACH(FMT_ADD_ARG_NAME, __VA_ARGS__)) { \
|
2014-07-01 23:23:50 +00:00
|
|
|
call(FMT_FOR_EACH(FMT_GET_ARG_NAME, __VA_ARGS__), fmt::ArgList()); \
|
2014-06-24 17:14:50 +00:00
|
|
|
} \
|
2014-07-01 23:23:50 +00:00
|
|
|
FMT_WRAP(Char, ReturnType, func, call, 1, __VA_ARGS__) \
|
|
|
|
FMT_WRAP(Char, ReturnType, func, call, 2, __VA_ARGS__) \
|
|
|
|
FMT_WRAP(Char, ReturnType, func, call, 3, __VA_ARGS__) \
|
|
|
|
FMT_WRAP(Char, ReturnType, func, call, 4, __VA_ARGS__) \
|
|
|
|
FMT_WRAP(Char, ReturnType, func, call, 5, __VA_ARGS__) \
|
|
|
|
FMT_WRAP(Char, ReturnType, func, call, 6, __VA_ARGS__) \
|
|
|
|
FMT_WRAP(Char, ReturnType, func, call, 7, __VA_ARGS__) \
|
|
|
|
FMT_WRAP(Char, ReturnType, func, call, 8, __VA_ARGS__) \
|
|
|
|
FMT_WRAP(Char, ReturnType, func, call, 9, __VA_ARGS__) \
|
2014-09-12 04:18:36 +00:00
|
|
|
FMT_WRAP(Char, ReturnType, func, call, 10, __VA_ARGS__) \
|
|
|
|
FMT_WRAP(Char, ReturnType, func, call, 11, __VA_ARGS__) \
|
|
|
|
FMT_WRAP(Char, ReturnType, func, call, 12, __VA_ARGS__) \
|
|
|
|
FMT_WRAP(Char, ReturnType, func, call, 13, __VA_ARGS__) \
|
|
|
|
FMT_WRAP(Char, ReturnType, func, call, 14, __VA_ARGS__) \
|
|
|
|
FMT_WRAP(Char, ReturnType, func, call, 15, __VA_ARGS__)
|
2014-06-28 20:31:44 +00:00
|
|
|
#endif // FMT_USE_VARIADIC_TEMPLATES
|
|
|
|
|
2014-06-29 02:44:39 +00:00
|
|
|
/**
|
2014-06-29 18:51:10 +00:00
|
|
|
\rst
|
|
|
|
Defines a variadic function with the specified return type, function name
|
|
|
|
and argument types passed as variable arguments to this macro.
|
2014-06-29 02:44:39 +00:00
|
|
|
|
2014-06-29 18:51:10 +00:00
|
|
|
**Example**::
|
2014-06-29 02:44:39 +00:00
|
|
|
|
2014-06-29 19:04:28 +00:00
|
|
|
void print_error(const char *file, int line, const char *format,
|
2014-09-21 15:08:52 +00:00
|
|
|
fmt::ArgList args) {
|
2014-06-29 19:04:28 +00:00
|
|
|
fmt::print("{}: {}: ", file, line);
|
|
|
|
fmt::print(format, args);
|
2014-06-29 02:44:39 +00:00
|
|
|
}
|
2014-06-29 19:04:28 +00:00
|
|
|
FMT_VARIADIC(void, print_error, const char *, int, const char *)
|
2014-08-21 14:30:00 +00:00
|
|
|
|
|
|
|
``FMT_VARIADIC`` is used for compatibility with legacy C++ compilers that
|
|
|
|
don't implement variadic templates. You don't have to use this macro if
|
|
|
|
you don't need legacy compiler support and can use variadic templates
|
|
|
|
directly::
|
|
|
|
|
2014-09-24 14:48:45 +00:00
|
|
|
template <typename... Args>
|
2014-08-21 14:30:00 +00:00
|
|
|
void print_error(const char *file, int line, const char *format,
|
|
|
|
const Args & ... args) {
|
|
|
|
fmt::print("{}: {}: ", file, line);
|
|
|
|
fmt::print(format, args...);
|
|
|
|
}
|
2014-06-29 18:51:10 +00:00
|
|
|
\endrst
|
2014-06-29 02:44:39 +00:00
|
|
|
*/
|
2014-06-28 22:58:02 +00:00
|
|
|
#define FMT_VARIADIC(ReturnType, func, ...) \
|
2014-07-01 23:23:50 +00:00
|
|
|
FMT_VARIADIC_(char, ReturnType, func, return func, __VA_ARGS__)
|
2014-06-28 22:58:02 +00:00
|
|
|
|
|
|
|
#define FMT_VARIADIC_W(ReturnType, func, ...) \
|
2014-07-01 23:23:50 +00:00
|
|
|
FMT_VARIADIC_(wchar_t, ReturnType, func, return func, __VA_ARGS__)
|
2014-06-28 22:58:02 +00:00
|
|
|
|
2015-06-10 01:32:59 +00:00
|
|
|
#define FMT_CAPTURE_ARG_(id, index) ::fmt::arg(#id, id)
|
|
|
|
|
|
|
|
#define FMT_CAPTURE_ARG_W_(id, index) ::fmt::arg(L###id, id)
|
|
|
|
|
|
|
|
/**
|
|
|
|
\rst
|
|
|
|
Convenient macro to capture the arguments' names and values into several
|
2015-06-10 14:33:17 +00:00
|
|
|
``fmt::arg(name, value)``.
|
2015-06-10 01:32:59 +00:00
|
|
|
|
|
|
|
**Example**::
|
|
|
|
|
|
|
|
int x = 1, y = 2;
|
|
|
|
print("point: ({x}, {y})", FMT_CAPTURE(x, y));
|
|
|
|
// same as:
|
|
|
|
// print("point: ({x}, {y})", arg("x", x), arg("y", y));
|
|
|
|
|
|
|
|
\endrst
|
|
|
|
*/
|
|
|
|
#define FMT_CAPTURE(...) FMT_FOR_EACH(FMT_CAPTURE_ARG_, __VA_ARGS__)
|
|
|
|
|
|
|
|
#define FMT_CAPTURE_W(...) FMT_FOR_EACH(FMT_CAPTURE_ARG_W_, __VA_ARGS__)
|
|
|
|
|
2014-06-28 22:58:02 +00:00
|
|
|
namespace fmt {
|
2015-06-26 14:43:54 +00:00
|
|
|
FMT_VARIADIC(std::string, format, CStringRef)
|
|
|
|
FMT_VARIADIC_W(std::wstring, format, WCStringRef)
|
|
|
|
FMT_VARIADIC(void, print, CStringRef)
|
|
|
|
FMT_VARIADIC(void, print, std::FILE *, CStringRef)
|
|
|
|
FMT_VARIADIC(void, print, std::ostream &, CStringRef)
|
|
|
|
FMT_VARIADIC(void, print_colored, Color, CStringRef)
|
|
|
|
FMT_VARIADIC(std::string, sprintf, CStringRef)
|
|
|
|
FMT_VARIADIC(int, printf, CStringRef)
|
|
|
|
FMT_VARIADIC(int, fprintf, std::FILE *, CStringRef)
|
2014-06-28 22:58:02 +00:00
|
|
|
}
|
2014-06-28 21:48:42 +00:00
|
|
|
|
2014-04-16 16:19:31 +00:00
|
|
|
// Restore warnings.
|
|
|
|
#if FMT_GCC_VERSION >= 406
|
|
|
|
# pragma GCC diagnostic pop
|
2013-12-06 15:00:06 +00:00
|
|
|
#endif
|
|
|
|
|
2015-02-07 05:25:30 +00:00
|
|
|
#ifdef __clang__
|
|
|
|
# pragma clang diagnostic pop
|
|
|
|
#endif
|
|
|
|
|
2014-11-28 14:40:57 +00:00
|
|
|
#ifdef FMT_HEADER_ONLY
|
|
|
|
# include "format.cc"
|
|
|
|
#endif
|
|
|
|
|
2014-04-24 00:33:50 +00:00
|
|
|
#endif // FMT_FORMAT_H_
|