mirror/fmt
1
0
Fork 0
mirror of https://github.com/fmtlib/fmt.git synced 2025-01-27 15:35:18 +00:00
Code Issues Packages Projects Releases Wiki Activity

Move FormatParser to the internal namespace.

Browse Source
This commit is contained in:
Victor Zverovich 2014-07-08 16:20:33 -07:00
parent f711266244
commit e825156add
4 changed files with 194 additions and 171 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

122
format.cc
View File

@ -154,6 +154,19 @@ int ParseNonnegativeInt(const Char *&s, const char *&error) FMT_NOEXCEPT(true) {
}
return value;
}
template <typename Char>
const Char *find_closing_brace(const Char *s, int num_open_braces = 1) {
for (int n = num_open_braces; *s; ++s) {
if (*s == '{') {
++n;
} else if (*s == '}') {
if (--n == 0)
return s;
}
}
throw fmt::FormatError("unmatched '{' in format");
}
} // namespace
int fmt::internal::SignBitNoInline(double value) { return SignBit(value); }
@ -357,16 +370,9 @@ void fmt::internal::FormatWinErrorMessage(
template <typename Char>
void fmt::internal::FormatErrorReporter<Char>::operator()(
const Char *s, fmt::StringRef message) const {
for (int n = num_open_braces; *s; ++s) {
if (*s == '{') {
++n;
} else if (*s == '}') {
if (--n == 0)
if (find_closing_brace(s, num_open_braces))
throw fmt::FormatError(message);
}
}
throw fmt::FormatError("unmatched '{' in format");
}
// Fills the padding around the content and returns the pointer to the
// content area.
@ -553,7 +559,7 @@ void fmt::BasicWriter<Char>::write_str(
template <typename Char>
inline const Arg
&fmt::BasicWriter<Char>::FormatParser::ParseArgIndex(const Char *&s) {
&fmt::internal::FormatParser<Char>::ParseArgIndex(const Char *&s) {
unsigned arg_index = 0;
if (*s < '0' || *s > '9') {
if (*s != '}' && *s != ':')
@ -580,7 +586,7 @@ inline const Arg
}
template <typename Char>
void fmt::BasicWriter<Char>::FormatParser::CheckSign(
void fmt::internal::FormatParser<Char>::CheckSign(
const Char *&s, const Arg &arg) {
char sign = static_cast<char>(*s);
if (arg.type > Arg::LAST_NUMERIC_TYPE) {
@ -851,7 +857,7 @@ void fmt::internal::PrintfParser<Char>::Format(
case Arg::CUSTOM:
if (spec.type_)
internal::ReportUnknownType(spec.type_, "object");
arg.custom.format(&writer, arg.custom.value, spec);
arg.custom.format(&writer, arg.custom.value, "s");
break;
default:
assert(false);
@ -862,33 +868,17 @@ void fmt::internal::PrintfParser<Char>::Format(
}
template <typename Char>
void fmt::BasicWriter<Char>::FormatParser::Format(
BasicWriter<Char> &writer, BasicStringRef<Char> format,
const ArgList &args) {
const Char *fmt::internal::FormatParser<Char>::format(
const Char *format_str, const internal::Arg &arg) {
const Char *s = format_str;
const char *error = 0;
const Char *start = format.c_str();
args_ = args;
next_arg_index_ = 0;
const Char *s = start;
while (*s) {
Char c = *s++;
if (c != '{' && c != '}') continue;
if (*s == c) {
writer.buffer_.append(start, s);
start = ++s;
continue;
}
if (c == '}')
throw FormatError("unmatched '}' in format");
report_error_.num_open_braces = 1;
writer.buffer_.append(start, s - 1);
const Arg &arg = ParseArgIndex(s);
FormatSpec spec;
if (*s == ':') {
if (arg.type == Arg::CUSTOM) {
arg.custom.format(this, arg.custom.value, s);
return find_closing_brace(s) + 1;
}
++s;
// Parse fill and alignment.
if (Char c = *s) {
const Char *p = s + 1;
@ -1015,27 +1005,27 @@ void fmt::BasicWriter<Char>::FormatParser::Format(
if (*s++ != '}')
throw FormatError("unmatched '{' in format");
start = s;
start_ = s;
// Format argument.
switch (arg.type) {
case Arg::INT:
writer.FormatInt(arg.int_value, spec);
writer_.FormatInt(arg.int_value, spec);
break;
case Arg::UINT:
writer.FormatInt(arg.uint_value, spec);
writer_.FormatInt(arg.uint_value, spec);
break;
case Arg::LONG_LONG:
writer.FormatInt(arg.long_long_value, spec);
writer_.FormatInt(arg.long_long_value, spec);
break;
case Arg::ULONG_LONG:
writer.FormatInt(arg.ulong_long_value, spec);
writer_.FormatInt(arg.ulong_long_value, spec);
break;
case Arg::DOUBLE:
writer.FormatDouble(arg.double_value, spec);
writer_.FormatDouble(arg.double_value, spec);
break;
case Arg::LONG_DOUBLE:
writer.FormatDouble(arg.long_double_value, spec);
writer_.FormatDouble(arg.long_double_value, spec);
break;
case Arg::CHAR: {
if (spec.type_ && spec.type_ != 'c')
@ -1044,45 +1034,66 @@ void fmt::BasicWriter<Char>::FormatParser::Format(
CharPtr out = CharPtr();
if (spec.width_ > 1) {
Char fill = static_cast<Char>(spec.fill());
out = writer.GrowBuffer(spec.width_);
out = writer_.GrowBuffer(spec.width_);
if (spec.align_ == ALIGN_RIGHT) {
std::fill_n(out, spec.width_ - 1, fill);
out += spec.width_ - 1;
} else if (spec.align_ == ALIGN_CENTER) {
out = writer.FillPadding(out, spec.width_, 1, fill);
out = writer_.FillPadding(out, spec.width_, 1, fill);
} else {
std::fill_n(out + 1, spec.width_ - 1, fill);
}
} else {
out = writer.GrowBuffer(1);
out = writer_.GrowBuffer(1);
}
*out = static_cast<Char>(arg.int_value);
break;
}
case Arg::STRING:
writer.write_str(arg.string, spec);
writer_.write_str(arg.string, spec);
break;
case Arg::WSTRING:
writer.write_str(internal::CharTraits<Char>::convert(arg.wstring), spec);
writer_.write_str(internal::CharTraits<Char>::convert(arg.wstring), spec);
break;
case Arg::POINTER:
if (spec.type_ && spec.type_ != 'p')
internal::ReportUnknownType(spec.type_, "pointer");
spec.flags_= HASH_FLAG;
spec.type_ = 'x';
writer.FormatInt(reinterpret_cast<uintptr_t>(arg.pointer_value), spec);
writer_.FormatInt(reinterpret_cast<uintptr_t>(arg.pointer_value), spec);
break;
case Arg::CUSTOM:
if (spec.type_)
internal::ReportUnknownType(spec.type_, "object");
arg.custom.format(&writer, arg.custom.value, spec);
arg.custom.format(this, arg.custom.value, s - 1);
break;
default:
assert(false);
break;
}
return s;
}
writer.buffer_.append(start, s);
template <typename Char>
void fmt::internal::FormatParser<Char>::Format(
BasicStringRef<Char> format_str, const ArgList &args) {
const Char *s = start_ = format_str.c_str();
args_ = args;
next_arg_index_ = 0;
while (*s) {
Char c = *s++;
if (c != '{' && c != '}') continue;
if (*s == c) {
writer_.buffer_.append(start_, s);
start_ = ++s;
continue;
}
if (c == '}')
throw FormatError("unmatched '}' in format");
report_error_.num_open_braces = 1;
writer_.buffer_.append(start_, s - 1);
Arg arg = ParseArgIndex(s);
s = format(s, arg);
}
writer_.buffer_.append(start_, s);
}
void fmt::ReportSystemError(
@ -1131,8 +1142,8 @@ template fmt::BasicWriter<char>::CharPtr
fmt::BasicWriter<char>::FillPadding(CharPtr buffer,
unsigned total_size, std::size_t content_size, wchar_t fill);
template void fmt::BasicWriter<char>::FormatParser::Format(
BasicWriter<char> &writer, BasicStringRef<char> format, const ArgList &args);
template void fmt::internal::FormatParser<char>::Format(
BasicStringRef<char> format, const ArgList &args);
template void fmt::internal::PrintfParser<char>::Format(
BasicWriter<char> &writer, BasicStringRef<char> format, const ArgList &args);
@ -1143,9 +1154,8 @@ template fmt::BasicWriter<wchar_t>::CharPtr
fmt::BasicWriter<wchar_t>::FillPadding(CharPtr buffer,
unsigned total_size, std::size_t content_size, wchar_t fill);
template void fmt::BasicWriter<wchar_t>::FormatParser::Format(
BasicWriter<wchar_t> &writer, BasicStringRef<wchar_t> format,
const ArgList &args);
template void fmt::internal::FormatParser<wchar_t>::Format(
BasicStringRef<wchar_t> format, const ArgList &args);
template void fmt::internal::PrintfParser<wchar_t>::Format(
BasicWriter<wchar_t> &writer, BasicStringRef<wchar_t> format,

76
format.h
View File

@ -130,8 +130,13 @@ typedef BasicWriter<wchar_t> WWriter;
struct FormatSpec;
namespace internal {
template <typename Char>
class FormatParser;
}
template <typename Char, typename T>
void format(BasicWriter<Char> &w, const FormatSpec &spec, const T &value);
void format(internal::FormatParser<Char> &f, const Char *format_str, const T &value);
/**
\rst
@ -598,7 +603,7 @@ struct Arg {
Type type;
typedef void (*FormatFunc)(
void *writer, const void *arg, const FormatSpec &spec);
void *formatter, const void *arg, const void *format_str);
struct CustomValue {
const void *value;
@ -648,9 +653,9 @@ class MakeArg : public Arg {
// Formats an argument of a custom type, such as a user-defined class.
template <typename T>
static void format_custom_arg(
void *writer, const void *arg, const FormatSpec &spec) {
format(*static_cast<BasicWriter<Char>*>(writer),
spec, *static_cast<const T*>(arg));
void *formatter, const void *arg, const void *format_str) {
format(*static_cast<FormatParser<Char>*>(formatter),
static_cast<const Char*>(format_str), *static_cast<const T*>(arg));
}
public:
@ -747,6 +752,32 @@ class ArgList {
};
namespace internal {
// Format string parser.
// TODO: rename to Formatter
template <typename Char>
class FormatParser {
private:
BasicWriter<Char> &writer_;
ArgList args_;
int next_arg_index_;
const Char *start_;
fmt::internal::FormatErrorReporter<Char> report_error_;
// Parses argument index and returns an argument with this index.
const internal::Arg &ParseArgIndex(const Char *&s);
void CheckSign(const Char *&s, const internal::Arg &arg);
public:
explicit FormatParser(BasicWriter<Char> &w) : writer_(w) {}
BasicWriter<Char> &writer() { return writer_; }
void Format(BasicStringRef<Char> format_str, const ArgList &args);
const Char *format(const Char *format_str, const internal::Arg &arg);
};
// Printf format string parser.
template <typename Char>
class PrintfParser {
@ -1225,23 +1256,7 @@ class BasicWriter {
// Do not implement!
void operator<<(typename internal::CharTraits<Char>::UnsupportedStrType);
// Format string parser.
class FormatParser {
private:
ArgList args_;
int next_arg_index_;
fmt::internal::FormatErrorReporter<Char> report_error_;
// Parses argument index and returns an argument with this index.
const internal::Arg &ParseArgIndex(const Char *&s);
void CheckSign(const Char *&s, const internal::Arg &arg);
public:
void Format(BasicWriter<Char> &writer,
BasicStringRef<Char> format, const ArgList &args);
};
friend class internal::FormatParser<Char>;
friend class internal::PrintfParser<Char>;
public:
@ -1321,8 +1336,8 @@ class BasicWriter {
See also `Format String Syntax`_.
\endrst
*/
inline void write(BasicStringRef<Char> format, const ArgList &args) {
FormatParser().Format(*this, format, args);
void write(BasicStringRef<Char> format, const ArgList &args) {
internal::FormatParser<Char>(*this).Format(format, args);
}
FMT_VARIADIC_VOID(write, fmt::BasicStringRef<Char>)
@ -1396,14 +1411,11 @@ class BasicWriter {
template <typename StringChar>
BasicWriter &operator<<(const StrFormatSpec<StringChar> &spec) {
const StringChar *s = spec.str();
// TODO: error if fill is not convertible to Char
write_str(s, std::char_traits<Char>::length(s), spec);
return *this;
}
void write_str(const std::basic_string<Char> &s, const FormatSpec &spec) {
write_str(s.data(), s.size(), spec);
}
void clear() { buffer_.clear(); }
};
@ -1469,7 +1481,6 @@ typename fmt::BasicWriter<Char>::CharPtr
}
CharPtr p = GrowBuffer(width);
CharPtr end = p + width;
// TODO: error if fill is not convertible to Char
if (align == ALIGN_LEFT) {
std::copy(prefix, prefix + prefix_size, p);
p += size;
@ -1575,12 +1586,13 @@ void BasicWriter<Char>::FormatInt(T value, const Spec &spec) {
}
}
// The default formatting function.
// Formats a value.
template <typename Char, typename T>
void format(BasicWriter<Char> &w, const FormatSpec &spec, const T &value) {
void format(internal::FormatParser<Char> &f,
const Char *format_str, const T &value) {
std::basic_ostringstream<Char> os;
os << value;
w.write_str(os.str(), spec);
f.format(format_str, internal::MakeArg<Char>(os.str()));
}
// Reports a system error without throwing an exception.

8
test/format-test.cc
View File

@ -519,7 +519,7 @@ TEST(WriterTest, pad) {
EXPECT_EQ(" 33", (Writer() << pad(33ll, 7)).str());
EXPECT_EQ(" 44", (Writer() << pad(44ull, 7)).str());
BasicWriter<char> w;
Writer w;
w.clear();
w << pad(42, 5, '0');
EXPECT_EQ("00042", w.str());
@ -1312,14 +1312,14 @@ TEST(FormatterTest, FormatUsingIOStreams) {
std::string s = format("The date is {0}", Date(2012, 12, 9));
EXPECT_EQ("The date is 2012-12-9", s);
Date date(2012, 12, 9);
CheckUnknownTypes(date, "", "object");
CheckUnknownTypes(date, "s", "string");
}
class Answer {};
template <typename Char>
void format(BasicWriter<Char> &w, const fmt::FormatSpec &spec, Answer) {
w.write_str("42", spec);
void format(fmt::internal::FormatParser<Char> &f, const Char *, Answer) {
f.writer() << "42";
}
TEST(FormatterTest, CustomFormat) {

3
test/util-test.cc
View File

@ -185,7 +185,8 @@ TEST(UtilTest, MakeArg) {
EXPECT_EQ(fmt::internal::Arg::CUSTOM, arg.type);
arg.custom.value = &t;
fmt::Writer w;
arg.custom.format(&w, &t, fmt::FormatSpec());
fmt::internal::FormatParser<char> formatter(w);
arg.custom.format(&formatter, &t, "}");
EXPECT_EQ("test", w.str());
}