feedc0de/fmt
1
0
Fork 0
forked from fmtlib/fmt
Code Pull Requests Activity

Parameterize Formatter on character type and rename it to BasicFormatter.

Browse Source
This commit is contained in:
Victor Zverovich
2013-02-05 07:28:54 -08:00
parent 03dccc3c91
commit 688de77b36
3 changed files with 412 additions and 410 deletions
Download Patch File Download Diff File Expand all files Collapse all files

322
format.cc
View File

@@ -33,47 +33,18 @@
#include <math.h>
// Wrap signbit because when compiled in C++11 mode signbit is no longer a
// macro but a function defined in namespace std and the macro is undefined.
#ifndef _MSC_VER
inline int SignBit(double value) { return signbit(value); }
#endif
#include "format.h"
#include <cassert>
#include <cctype>
#include <climits>
#include <cstring>
#include <algorithm>
using std::size_t;
using fmt::IntFormatter;
using fmt::Formatter;
using fmt::AlignSpec;
using fmt::FormatSpec;
using fmt::WidthSpec;
using fmt::StringRef;
#if _MSC_VER
# undef snprintf
# define snprintf _snprintf
# define isinf(x) (!_finite(x))
#endif
namespace {
#ifdef _MSC_VER
int SignBit(double value) {
if (value < 0) return 1;
if (value == value) return 0;
int dec = 0, sign = 0;
_ecvt(value, 0, &dec, &sign);
return sign;
}
#endif
}
const char fmt::internal::DIGITS[] =
"0001020304050607080910111213141516171819"
"2021222324252627282930313233343536373839"
@@ -90,296 +61,3 @@ void fmt::internal::ReportUnknownType(char code, const char *type) {
fmt::str(fmt::Format("unknown format code '\\x{:02x}' for {}")
<< static_cast<unsigned>(code) << type));
}
// Throws Exception(message) if format contains '}', otherwise throws
// FormatError reporting unmatched '{'. The idea is that unmatched '{'
// should override other errors.
void Formatter::ReportError(const char *s, StringRef message) const {
for (int num_open_braces = num_open_braces_; *s; ++s) {
if (*s == '{') {
++num_open_braces;
} else if (*s == '}') {
if (--num_open_braces == 0)
throw fmt::FormatError(message);
}
}
throw fmt::FormatError("unmatched '{' in format");
}
// Parses an unsigned integer advancing s to the end of the parsed input.
// This function assumes that the first character of s is a digit.
unsigned Formatter::ParseUInt(const char *&s) const {
assert('0' <= *s && *s <= '9');
unsigned value = 0;
do {
unsigned new_value = value * 10 + (*s++ - '0');
if (new_value < value) // Check if value wrapped around.
ReportError(s, "number is too big in format");
value = new_value;
} while ('0' <= *s && *s <= '9');
return value;
}
inline const Formatter::Arg &Formatter::ParseArgIndex(const char *&s) {
unsigned arg_index = 0;
if (*s < '0' || *s > '9') {
if (*s != '}' && *s != ':')
ReportError(s, "invalid argument index in format string");
if (next_arg_index_ < 0) {
ReportError(s,
"cannot switch from manual to automatic argument indexing");
}
arg_index = next_arg_index_++;
} else {
if (next_arg_index_ > 0) {
ReportError(s,
"cannot switch from automatic to manual argument indexing");
}
next_arg_index_ = -1;
arg_index = ParseUInt(s);
if (arg_index >= args_.size())
ReportError(s, "argument index is out of range in format");
}
return *args_[arg_index];
}
void Formatter::CheckSign(const char *&s, const Arg &arg) {
if (arg.type > LAST_NUMERIC_TYPE) {
ReportError(s,
Format("format specifier '{0}' requires numeric argument") << *s);
}
if (arg.type == UINT || arg.type == ULONG) {
ReportError(s,
Format("format specifier '{0}' requires signed argument") << *s);
}
++s;
}
void Formatter::DoFormat() {
const char *start = format_;
format_ = 0;
next_arg_index_ = 0;
const char *s = start;
while (*s) {
char c = *s++;
if (c != '{' && c != '}') continue;
if (*s == c) {
buffer_.append(start, s);
start = ++s;
continue;
}
if (c == '}')
throw FormatError("unmatched '}' in format");
num_open_braces_= 1;
buffer_.append(start, s - 1);
const Arg &arg = ParseArgIndex(s);
FormatSpec spec;
int precision = -1;
if (*s == ':') {
++s;
// Parse fill and alignment.
if (char c = *s) {
const char *p = s + 1;
spec.align_ = ALIGN_DEFAULT;
do {
switch (*p) {
case '<':
spec.align_ = ALIGN_LEFT;
break;
case '>':
spec.align_ = ALIGN_RIGHT;
break;
case '=':
spec.align_ = ALIGN_NUMERIC;
break;
case '^':
spec.align_ = ALIGN_CENTER;
break;
}
if (spec.align_ != ALIGN_DEFAULT) {
if (p != s) {
if (c == '}') break;
if (c == '{')
ReportError(s, "invalid fill character '{'");
s += 2;
spec.fill_ = c;
} else ++s;
if (spec.align_ == ALIGN_NUMERIC && arg.type > LAST_NUMERIC_TYPE)
ReportError(s, "format specifier '=' requires numeric argument");
break;
}
} while (--p >= s);
}
// Parse sign.
switch (*s) {
case '+':
CheckSign(s, arg);
spec.flags_ |= SIGN_FLAG | PLUS_FLAG;
break;
case '-':
CheckSign(s, arg);
break;
case ' ':
CheckSign(s, arg);
spec.flags_ |= SIGN_FLAG;
break;
}
if (*s == '#') {
if (arg.type > LAST_NUMERIC_TYPE)
ReportError(s, "format specifier '#' requires numeric argument");
spec.flags_ |= HASH_FLAG;
++s;
}
// Parse width and zero flag.
if ('0' <= *s && *s <= '9') {
if (*s == '0') {
if (arg.type > LAST_NUMERIC_TYPE)
ReportError(s, "format specifier '0' requires numeric argument");
spec.align_ = ALIGN_NUMERIC;
spec.fill_ = '0';
}
// Zero may be parsed again as a part of the width, but it is simpler
// and more efficient than checking if the next char is a digit.
unsigned value = ParseUInt(s);
if (value > INT_MAX)
ReportError(s, "number is too big in format");
spec.width_ = value;
}
// Parse precision.
if (*s == '.') {
++s;
precision = 0;
if ('0' <= *s && *s <= '9') {
unsigned value = ParseUInt(s);
if (value > INT_MAX)
ReportError(s, "number is too big in format");
precision = value;
} else if (*s == '{') {
++s;
++num_open_braces_;
const Arg &precision_arg = ParseArgIndex(s);
unsigned long value = 0;
switch (precision_arg.type) {
case INT:
if (precision_arg.int_value < 0)
ReportError(s, "negative precision in format");
value = precision_arg.int_value;
break;
case UINT:
value = precision_arg.uint_value;
break;
case LONG:
if (precision_arg.long_value < 0)
ReportError(s, "negative precision in format");
value = precision_arg.long_value;
break;
case ULONG:
value = precision_arg.ulong_value;
break;
default:
ReportError(s, "precision is not integer");
}
if (value > INT_MAX)
ReportError(s, "number is too big in format");
precision = value;
if (*s++ != '}')
throw FormatError("unmatched '{' in format");
--num_open_braces_;
} else {
ReportError(s, "missing precision in format");
}
if (arg.type != DOUBLE && arg.type != LONG_DOUBLE) {
ReportError(s,
"precision specifier requires floating-point argument");
}
}
// Parse type.
if (*s != '}' && *s)
spec.type_ = *s++;
}
if (*s++ != '}')
throw FormatError("unmatched '{' in format");
start = s;
// Format argument.
switch (arg.type) {
case INT:
FormatInt(arg.int_value, spec);
break;
case UINT:
FormatInt(arg.uint_value, spec);
break;
case LONG:
FormatInt(arg.long_value, spec);
break;
case ULONG:
FormatInt(arg.ulong_value, spec);
break;
case DOUBLE:
FormatDouble(arg.double_value, spec, precision);
break;
case LONG_DOUBLE:
FormatDouble(arg.long_double_value, spec, precision);
break;
case CHAR: {
if (spec.type_ && spec.type_ != 'c')
internal::ReportUnknownType(spec.type_, "char");
char *out = 0;
if (spec.width_ > 1) {
out = GrowBuffer(spec.width_);
if (spec.align_ == ALIGN_RIGHT) {
std::fill_n(out, spec.width_ - 1, spec.fill_);
out += spec.width_ - 1;
} else if (spec.align_ == ALIGN_CENTER) {
out = FillPadding(out, spec.width_, 1, spec.fill_);
} else {
std::fill_n(out + 1, spec.width_ - 1, spec.fill_);
}
} else {
out = GrowBuffer(1);
}
*out = arg.int_value;
break;
}
case STRING: {
if (spec.type_ && spec.type_ != 's')
internal::ReportUnknownType(spec.type_, "string");
const char *str = arg.string.value;
size_t size = arg.string.size;
if (size == 0) {
if (!str)
throw FormatError("string pointer is null");
if (*str)
size = std::strlen(str);
}
FormatString(str, size, spec);
break;
}
case POINTER:
if (spec.type_ && spec.type_ != 'p')
internal::ReportUnknownType(spec.type_, "pointer");
spec.flags_= HASH_FLAG;
spec.type_ = 'x';
FormatInt(reinterpret_cast<uintptr_t>(arg.pointer_value), spec);
break;
case CUSTOM:
if (spec.type_)
internal::ReportUnknownType(spec.type_, "object");
(this->*arg.custom.format)(arg.custom.value, spec);
break;
default:
assert(false);
break;
}
}
buffer_.append(start, s);
}

479
format.h
View File

@@ -30,6 +30,9 @@
#include <stdint.h>
#include <cassert>
#include <climits>
#include <cmath>
#include <cstddef>
#include <cstdio>
#include <cstring>
@@ -146,7 +149,44 @@ extern const char DIGITS[];
void ReportUnknownType(char code, const char *type);
// Returns the number of decimal digits in n. Trailing zeros are not counted
// except for n == 0 in which case CountDigits returns 1.
inline unsigned CountDigits(uint64_t n) {
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;
}
}
#ifndef _MSC_VER
inline int SignBit(double value) {
// When compiled in C++11 mode signbit is no longer a macro but a function
// defined in namespace std and the macro is undefined.
using namespace std;
return signbit(value);
}
#else
inline int SignBit(double value) {
if (value < 0) return 1;
if (value == value) return 0;
int dec = 0, sign = 0;
_ecvt(value, 0, &dec, &sign);
return sign;
}
#endif
template <typename Char>
class ArgInserter;
template <typename Char>
class FormatterProxy;
}
@@ -354,23 +394,6 @@ DEFINE_INT_FORMATTERS(unsigned long)
template <typename Char>
class BasicWriter {
private:
// Returns the number of decimal digits in n. Trailing zeros are not counted
// except for n == 0 in which case CountDigits returns 1.
static unsigned CountDigits(uint64_t n) {
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;
}
}
static void FormatDecimal(Char *buffer, uint64_t value, unsigned num_digits);
protected:
@@ -477,7 +500,7 @@ Char *BasicWriter<Char>::FillPadding(Char *buffer,
std::size_t left_padding = padding / 2;
std::fill_n(buffer, left_padding, fill);
buffer += left_padding;
char *content = buffer;
Char *content = buffer;
std::fill_n(buffer + content_size, padding - left_padding, fill);
return content;
}
@@ -510,7 +533,7 @@ Char *BasicWriter<Char>::PrepareFilledBuffer(
unsigned size, const AlignSpec &spec, char sign) {
unsigned width = spec.width();
if (width <= size) {
char *p = GrowBuffer(size);
Char *p = GrowBuffer(size);
*p = sign;
return p + size - 1;
}
@@ -570,7 +593,7 @@ void BasicWriter<Char>::FormatDouble(
char sign = 0;
// Use SignBit instead of value < 0 because the latter is always
// false for NaN.
if (SignBit(value)) {
if (internal::SignBit(value)) {
sign = '-';
value = -value;
} else if (spec.sign_flag()) {
@@ -607,7 +630,7 @@ void BasicWriter<Char>::FormatDouble(
return;
}
size_t offset = buffer_.size();
std::size_t offset = buffer_.size();
unsigned width = spec.width();
if (sign) {
buffer_.reserve(buffer_.size() + std::max(width, 1u));
@@ -643,9 +666,9 @@ void BasicWriter<Char>::FormatDouble(
// Format using snprintf.
for (;;) {
size_t size = buffer_.capacity() - offset;
std::size_t size = buffer_.capacity() - offset;
int n = 0;
char *start = &buffer_[offset];
Char *start = &buffer_[offset];
if (width_for_sprintf == 0) {
n = precision < 0 ?
snprintf(start, size, format, value) :
@@ -726,7 +749,7 @@ BasicWriter<Char> &BasicWriter<Char>::operator<<(
}
switch (f.type()) {
case 0: case 'd': {
unsigned num_digits = BasicWriter::CountDigits(abs_value);
unsigned num_digits = internal::CountDigits(abs_value);
Char *p = PrepareFilledBuffer(size + num_digits, f, sign) - num_digits + 1;
BasicWriter::FormatDecimal(p, abs_value, num_digits);
break;
@@ -787,7 +810,7 @@ void Format(BasicWriter<Char> &f, const FormatSpec &spec, const T &value) {
/**
\rst
The :cpp:class:`fmt::Formatter` class provides string formatting
The :cpp:class:`fmt::BasicFormatter` template provides string formatting
functionality similar to Python's `str.format
<http://docs.python.org/3/library/stdtypes.html#str.format>`__.
The output is stored in a memory buffer that grows dynamically.
@@ -809,7 +832,8 @@ void Format(BasicWriter<Char> &f, const FormatSpec &spec, const T &value) {
The buffer can be accessed using :meth:`data` or :meth:`c_str`.
\endrst
*/
class Formatter : public BasicWriter<char> {
template <typename Char>
class BasicFormatter : public BasicWriter<Char> {
private:
enum Type {
// Numeric types should go first.
@@ -818,7 +842,7 @@ class Formatter : public BasicWriter<char> {
CHAR, STRING, WSTRING, POINTER, CUSTOM
};
typedef void (Formatter::*FormatFunc)(
typedef void (BasicFormatter::*FormatFunc)(
const void *arg, const FormatSpec &spec);
// A format argument.
@@ -858,7 +882,7 @@ class Formatter : public BasicWriter<char> {
FormatFunc format;
} custom;
};
mutable Formatter *formatter;
mutable BasicFormatter *formatter;
Arg(int value) : type(INT), int_value(value), formatter(0) {}
Arg(unsigned value) : type(UINT), uint_value(value), formatter(0) {}
@@ -892,7 +916,7 @@ class Formatter : public BasicWriter<char> {
template <typename T>
Arg(const T &value) : type(CUSTOM), formatter(0) {
custom.value = &value;
custom.format = &Formatter::FormatCustomArg<T>;
custom.format = &BasicFormatter::FormatCustomArg<T>;
}
~Arg() {
@@ -914,12 +938,12 @@ class Formatter : public BasicWriter<char> {
enum { NUM_INLINE_ARGS = 10 };
internal::Array<const Arg*, NUM_INLINE_ARGS> args_; // Format arguments.
const char *format_; // Format string.
const Char *format_; // Format string.
int num_open_braces_;
int next_arg_index_;
friend class internal::ArgInserter;
friend class internal::FormatterProxy;
friend class internal::ArgInserter<Char>;
friend class internal::FormatterProxy<Char>;
void Add(const Arg &arg) {
args_.push_back(&arg);
@@ -930,7 +954,7 @@ class Formatter : public BasicWriter<char> {
// Formats an argument of a custom type, such as a user-defined class.
template <typename T>
void FormatCustomArg(const void *arg, const FormatSpec &spec) {
BasicWriter &f = *this;
BasicWriter<Char> &f = *this;
Format(f, spec, *static_cast<const T*>(arg));
}
@@ -952,16 +976,19 @@ class Formatter : public BasicWriter<char> {
/**
Constructs a formatter with an empty output buffer.
*/
Formatter() : format_(0) {}
BasicFormatter() : format_(0) {}
/**
Formats a string appending the output to the internal buffer.
Arguments are accepted through the returned `ArgInserter` object
using inserter operator `<<`.
*/
internal::ArgInserter operator()(StringRef format);
internal::ArgInserter<Char> operator()(StringRef format);
};
typedef BasicFormatter<char> Formatter;
typedef BasicFormatter<wchar_t> WFormatter;
template <typename Char>
inline std::basic_string<Char> str(const BasicWriter<Char> &f) {
return f.str();
@@ -970,22 +997,23 @@ inline std::basic_string<Char> str(const BasicWriter<Char> &f) {
template <typename Char>
inline const Char *c_str(const BasicWriter<Char> &f) { return f.c_str(); }
std::string str(internal::FormatterProxy p);
const char *c_str(internal::FormatterProxy p);
std::string str(internal::FormatterProxy<char> p);
const char *c_str(internal::FormatterProxy<char> p);
namespace internal {
using fmt::str;
using fmt::c_str;
template <typename Char>
class FormatterProxy {
private:
Formatter *formatter_;
BasicFormatter<Char> *formatter_;
public:
explicit FormatterProxy(Formatter *f) : formatter_(f) {}
explicit FormatterProxy(BasicFormatter<Char> *f) : formatter_(f) {}
Formatter *Format() {
BasicFormatter<Char> *Format() {
formatter_->CompleteFormatting();
return formatter_;
}
@@ -995,20 +1023,21 @@ class FormatterProxy {
// returned by one of the formatting functions. It stores a reference
// to a formatter and provides operator<< that feeds arguments to the
// formatter.
template <typename Char>
class ArgInserter {
private:
mutable Formatter *formatter_;
mutable BasicFormatter<Char> *formatter_;
friend class fmt::Formatter;
friend class fmt::BasicFormatter<Char>;
friend class fmt::StringRef;
// Do not implement.
void operator=(const ArgInserter& other);
protected:
explicit ArgInserter(Formatter *f = 0) : formatter_(f) {}
explicit ArgInserter(BasicFormatter<Char> *f = 0) : formatter_(f) {}
void Init(Formatter &f, const char *format) {
void Init(BasicFormatter<Char> &f, const char *format) {
const ArgInserter &other = f(format);
formatter_ = other.formatter_;
other.formatter_ = 0;
@@ -1019,8 +1048,8 @@ class ArgInserter {
other.formatter_ = 0;
}
const Formatter *Format() const {
Formatter *f = formatter_;
const BasicFormatter<Char> *Format() const {
BasicFormatter<Char> *f = formatter_;
if (f) {
formatter_ = 0;
f->CompleteFormatting();
@@ -1028,7 +1057,7 @@ class ArgInserter {
return f;
}
Formatter *formatter() const { return formatter_; }
BasicFormatter<Char> *formatter() const { return formatter_; }
const char *format() const { return formatter_->format_; }
void ResetFormatter() const { formatter_ = 0; }
@@ -1040,20 +1069,20 @@ class ArgInserter {
}
// Feeds an argument to a formatter.
ArgInserter &operator<<(const Formatter::Arg &arg) {
ArgInserter &operator<<(const typename BasicFormatter<Char>::Arg &arg) {
arg.formatter = formatter_;
formatter_->Add(arg);
return *this;
}
operator FormatterProxy() {
Formatter *f = formatter_;
operator FormatterProxy<Char>() {
BasicFormatter<Char> *f = formatter_;
formatter_ = 0;
return FormatterProxy(f);
return FormatterProxy<Char>(f);
}
operator StringRef() {
const Formatter *f = Format();
const BasicFormatter<Char> *f = Format();
return StringRef(f->c_str(), f->size());
}
};
@@ -1062,7 +1091,7 @@ class ArgInserter {
/**
Returns the content of the output buffer as an `std::string`.
*/
inline std::string str(internal::FormatterProxy p) {
inline std::string str(internal::FormatterProxy<char> p) {
return p.Format()->str();
}
@@ -1070,15 +1099,17 @@ inline std::string str(internal::FormatterProxy p) {
Returns a pointer to the output buffer content with terminating null
character appended.
*/
inline const char *c_str(internal::FormatterProxy p) {
inline const char *c_str(internal::FormatterProxy<char> p) {
return p.Format()->c_str();
}
inline internal::ArgInserter Formatter::operator()(StringRef format) {
internal::ArgInserter formatter(this);
template <typename Char>
inline internal::ArgInserter<Char>
BasicFormatter<Char>::operator()(StringRef format) {
internal::ArgInserter<Char> inserter(this);
format_ = format.c_str();
args_.clear();
return formatter;
return inserter;
}
/**
@@ -1087,7 +1118,8 @@ inline internal::ArgInserter Formatter::operator()(StringRef format) {
class NoAction {
public:
/** Does nothing. */
void operator()(const Formatter &) const {}
template <typename Char>
void operator()(const BasicFormatter<Char> &) const {}
};
/**
@@ -1095,10 +1127,10 @@ class NoAction {
Objects of this class normally exist only as temporaries returned
by one of the formatting functions which explains the name.
*/
template <typename Action = NoAction>
class TempFormatter : public internal::ArgInserter {
template <typename Char, typename Action = NoAction>
class TempFormatter : public internal::ArgInserter<Char> {
private:
Formatter formatter_;
BasicFormatter<Char> formatter_;
Action action_;
// Forbid copying other than from a temporary. Do not implement.
@@ -1119,38 +1151,38 @@ class TempFormatter : public internal::ArgInserter {
\rst
Constructs a temporary formatter with a format string and an action.
The action should be an unary function object that takes a const
reference to :cpp:class:`fmt::Formatter` as an argument.
reference to :cpp:class:`fmt::BasicFormatter` as an argument.
See :cpp:class:`fmt::NoAction` and :cpp:class:`fmt::Write` for
examples of action classes.
\endrst
*/
explicit TempFormatter(StringRef format, Action a = Action())
: action_(a) {
Init(formatter_, format.c_str());
this->Init(formatter_, format.c_str());
}
/**
Constructs a temporary formatter from a proxy object.
*/
TempFormatter(const Proxy &p)
: ArgInserter(0), action_(p.action) {
Init(formatter_, p.format);
: internal::ArgInserter<Char>(0), action_(p.action) {
this->Init(formatter_, p.format);
}
/**
Performs the actual formatting, invokes the action and destroys the object.
*/
~TempFormatter() {
if (formatter())
action_(*Format());
if (this->formatter())
action_(*this->Format());
}
/**
Converts a temporary formatter into a proxy object.
*/
operator Proxy() {
const char *fmt = format();
ResetFormatter();
const char *fmt = this->format();
this->ResetFormatter();
return Proxy(fmt, action_);
}
};
@@ -1172,13 +1204,13 @@ class TempFormatter : public internal::ArgInserter {
See also `Format String Syntax`_.
\endrst
*/
inline TempFormatter<> Format(StringRef format) {
return TempFormatter<>(format);
inline TempFormatter<char> Format(StringRef format) {
return TempFormatter<char>(format);
}
// A formatting action that writes formatted output to stdout.
struct Write {
void operator()(const Formatter &f) const {
void operator()(const BasicFormatter<char> &f) const {
std::fwrite(f.data(), 1, f.size(), stdout);
}
};
@@ -1186,8 +1218,307 @@ struct Write {
// Formats a string and prints it to stdout.
// Example:
// Print("Elapsed time: {0:.2f} seconds") << 1.23;
inline TempFormatter<Write> Print(StringRef format) {
return TempFormatter<Write>(format);
inline TempFormatter<char, Write> Print(StringRef format) {
return TempFormatter<char, Write>(format);
}
// Throws Exception(message) if format contains '}', otherwise throws
// FormatError reporting unmatched '{'. The idea is that unmatched '{'
// should override other errors.
template <typename Char>
void BasicFormatter<Char>::ReportError(const char *s, StringRef message) const {
for (int num_open_braces = num_open_braces_; *s; ++s) {
if (*s == '{') {
++num_open_braces;
} else if (*s == '}') {
if (--num_open_braces == 0)
throw fmt::FormatError(message);
}
}
throw fmt::FormatError("unmatched '{' in format");
}
// Parses an unsigned integer advancing s to the end of the parsed input.
// This function assumes that the first character of s is a digit.
template <typename Char>
unsigned BasicFormatter<Char>::ParseUInt(const char *&s) const {
assert('0' <= *s && *s <= '9');
unsigned value = 0;
do {
unsigned new_value = value * 10 + (*s++ - '0');
if (new_value < value) // Check if value wrapped around.
ReportError(s, "number is too big in format");
value = new_value;
} while ('0' <= *s && *s <= '9');
return value;
}
template <typename Char>
inline const typename BasicFormatter<Char>::Arg
&BasicFormatter<Char>::ParseArgIndex(const char *&s) {
unsigned arg_index = 0;
if (*s < '0' || *s > '9') {
if (*s != '}' && *s != ':')
ReportError(s, "invalid argument index in format string");
if (next_arg_index_ < 0) {
ReportError(s,
"cannot switch from manual to automatic argument indexing");
}
arg_index = next_arg_index_++;
} else {
if (next_arg_index_ > 0) {
ReportError(s,
"cannot switch from automatic to manual argument indexing");
}
next_arg_index_ = -1;
arg_index = ParseUInt(s);
if (arg_index >= args_.size())
ReportError(s, "argument index is out of range in format");
}
return *args_[arg_index];
}
template <typename Char>
void BasicFormatter<Char>::CheckSign(const char *&s, const Arg &arg) {
if (arg.type > LAST_NUMERIC_TYPE) {
ReportError(s,
Format("format specifier '{0}' requires numeric argument") << *s);
}
if (arg.type == UINT || arg.type == ULONG) {
ReportError(s,
Format("format specifier '{0}' requires signed argument") << *s);
}
++s;
}
template <typename Char>
void BasicFormatter<Char>::DoFormat() {
const Char *start = format_;
format_ = 0;
next_arg_index_ = 0;
const Char *s = start;
while (*s) {
char c = *s++;
if (c != '{' && c != '}') continue;
if (*s == c) {
this->buffer_.append(start, s);
start = ++s;
continue;
}
if (c == '}')
throw FormatError("unmatched '}' in format");
num_open_braces_= 1;
this->buffer_.append(start, s - 1);
const Arg &arg = ParseArgIndex(s);
FormatSpec spec;
int precision = -1;
if (*s == ':') {
++s;
// Parse fill and alignment.
if (char c = *s) {
const char *p = s + 1;
spec.align_ = ALIGN_DEFAULT;
do {
switch (*p) {
case '<':
spec.align_ = ALIGN_LEFT;
break;
case '>':
spec.align_ = ALIGN_RIGHT;
break;
case '=':
spec.align_ = ALIGN_NUMERIC;
break;
case '^':
spec.align_ = ALIGN_CENTER;
break;
}
if (spec.align_ != ALIGN_DEFAULT) {
if (p != s) {
if (c == '}') break;
if (c == '{')
ReportError(s, "invalid fill character '{'");
s += 2;
spec.fill_ = c;
} else ++s;
if (spec.align_ == ALIGN_NUMERIC && arg.type > LAST_NUMERIC_TYPE)
ReportError(s, "format specifier '=' requires numeric argument");
break;
}
} while (--p >= s);
}
// Parse sign.
switch (*s) {
case '+':
CheckSign(s, arg);
spec.flags_ |= SIGN_FLAG | PLUS_FLAG;
break;
case '-':
CheckSign(s, arg);
break;
case ' ':
CheckSign(s, arg);
spec.flags_ |= SIGN_FLAG;
break;
}
if (*s == '#') {
if (arg.type > LAST_NUMERIC_TYPE)
ReportError(s, "format specifier '#' requires numeric argument");
spec.flags_ |= HASH_FLAG;
++s;
}
// Parse width and zero flag.
if ('0' <= *s && *s <= '9') {
if (*s == '0') {
if (arg.type > LAST_NUMERIC_TYPE)
ReportError(s, "format specifier '0' requires numeric argument");
spec.align_ = ALIGN_NUMERIC;
spec.fill_ = '0';
}
// Zero may be parsed again as a part of the width, but it is simpler
// and more efficient than checking if the next char is a digit.
unsigned value = ParseUInt(s);
if (value > INT_MAX)
ReportError(s, "number is too big in format");
spec.width_ = value;
}
// Parse precision.
if (*s == '.') {
++s;
precision = 0;
if ('0' <= *s && *s <= '9') {
unsigned value = ParseUInt(s);
if (value > INT_MAX)
ReportError(s, "number is too big in format");
precision = value;
} else if (*s == '{') {
++s;
++num_open_braces_;
const Arg &precision_arg = ParseArgIndex(s);
unsigned long value = 0;
switch (precision_arg.type) {
case INT:
if (precision_arg.int_value < 0)
ReportError(s, "negative precision in format");
value = precision_arg.int_value;
break;
case UINT:
value = precision_arg.uint_value;
break;
case LONG:
if (precision_arg.long_value < 0)
ReportError(s, "negative precision in format");
value = precision_arg.long_value;
break;
case ULONG:
value = precision_arg.ulong_value;
break;
default:
ReportError(s, "precision is not integer");
}
if (value > INT_MAX)
ReportError(s, "number is too big in format");
precision = value;
if (*s++ != '}')
throw FormatError("unmatched '{' in format");
--num_open_braces_;
} else {
ReportError(s, "missing precision in format");
}
if (arg.type != DOUBLE && arg.type != LONG_DOUBLE) {
ReportError(s,
"precision specifier requires floating-point argument");
}
}
// Parse type.
if (*s != '}' && *s)
spec.type_ = *s++;
}
if (*s++ != '}')
throw FormatError("unmatched '{' in format");
start = s;
// Format argument.
switch (arg.type) {
case INT:
this->FormatInt(arg.int_value, spec);
break;
case UINT:
this->FormatInt(arg.uint_value, spec);
break;
case LONG:
this->FormatInt(arg.long_value, spec);
break;
case ULONG:
this->FormatInt(arg.ulong_value, spec);
break;
case DOUBLE:
this->FormatDouble(arg.double_value, spec, precision);
break;
case LONG_DOUBLE:
this->FormatDouble(arg.long_double_value, spec, precision);
break;
case CHAR: {
if (spec.type_ && spec.type_ != 'c')
internal::ReportUnknownType(spec.type_, "char");
char *out = 0;
if (spec.width_ > 1) {
out = this->GrowBuffer(spec.width_);
if (spec.align_ == ALIGN_RIGHT) {
std::fill_n(out, spec.width_ - 1, spec.fill_);
out += spec.width_ - 1;
} else if (spec.align_ == ALIGN_CENTER) {
out = this->FillPadding(out, spec.width_, 1, spec.fill_);
} else {
std::fill_n(out + 1, spec.width_ - 1, spec.fill_);
}
} else {
out = this->GrowBuffer(1);
}
*out = arg.int_value;
break;
}
case STRING: {
if (spec.type_ && spec.type_ != 's')
internal::ReportUnknownType(spec.type_, "string");
const char *str = arg.string.value;
std::size_t size = arg.string.size;
if (size == 0) {
if (!str)
throw FormatError("string pointer is null");
if (*str)
size = std::strlen(str);
}
this->FormatString(str, size, spec);
break;
}
case POINTER:
if (spec.type_ && spec.type_ != 'p')
internal::ReportUnknownType(spec.type_, "pointer");
spec.flags_= HASH_FLAG;
spec.type_ = 'x';
this->FormatInt(reinterpret_cast<uintptr_t>(arg.pointer_value), spec);
break;
case CUSTOM:
if (spec.type_)
internal::ReportUnknownType(spec.type_, "object");
(this->*arg.custom.format)(arg.custom.value, spec);
break;
default:
assert(false);
break;
}
}
this->buffer_.append(start, s);
}
}

21
format_test.cc
View File

@@ -25,12 +25,6 @@
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
// Disable useless MSVC warnings.
#undef _CRT_SECURE_NO_WARNINGS
#define _CRT_SECURE_NO_WARNINGS
#undef _SCL_SECURE_NO_WARNINGS
#define _SCL_SECURE_NO_WARNINGS
#include <cctype>
#include <cfloat>
#include <climits>
@@ -980,7 +974,7 @@ struct CountCalls {
TEST(TempFormatterTest, Action) {
int num_calls = 0;
{
fmt::TempFormatter<CountCalls> af("test", CountCalls(num_calls));
fmt::TempFormatter<char, CountCalls> af("test", CountCalls(num_calls));
EXPECT_EQ(0, num_calls);
}
EXPECT_EQ(1, num_calls);
@@ -989,9 +983,8 @@ TEST(TempFormatterTest, Action) {
TEST(TempFormatterTest, ActionNotCalledOnError) {
int num_calls = 0;
{
EXPECT_THROW(
fmt::TempFormatter<CountCalls> af("{0", CountCalls(num_calls)),
FormatError);
typedef fmt::TempFormatter<char, CountCalls> TestFormatter;
EXPECT_THROW(TestFormatter af("{0", CountCalls(num_calls)), FormatError);
}
EXPECT_EQ(0, num_calls);
}
@@ -1003,8 +996,8 @@ TEST(TempFormatterTest, ActionNotCalledOnError) {
TEST(TempFormatterTest, ArgLifetime) {
// The following code is for testing purposes only. It is a definite abuse
// of the API and shouldn't be used in real applications.
const fmt::TempFormatter<> &af = fmt::Format("{0}");
const_cast<fmt::TempFormatter<>&>(af) << std::string("test");
const fmt::TempFormatter<char> &af = fmt::Format("{0}");
const_cast<fmt::TempFormatter<char>&>(af) << std::string("test");
// String object passed as an argument to TempFormatter has
// been destroyed, but ArgInserter dtor hasn't been called yet.
// But that's OK since the Arg's dtor takes care of this and
@@ -1023,8 +1016,8 @@ struct PrintError {
}
};
fmt::TempFormatter<PrintError> ReportError(const char *format) {
return fmt::TempFormatter<PrintError>(format);
fmt::TempFormatter<char, PrintError> ReportError(const char *format) {
return fmt::TempFormatter<char, PrintError>(format);
}
TEST(TempFormatterTest, Examples) {