From 270069beda770734b20330c866a09e1775bee795 Mon Sep 17 00:00:00 2001 From: vitaut Date: Tue, 16 Jun 2015 07:36:32 -0700 Subject: [PATCH] Use arg visitor when formatting printf argument and get rid of ignore_incompatible_str. --- format.cc | 287 ++++++++++++++++++++++++------------------------------ format.h | 11 ++- 2 files changed, 134 insertions(+), 164 deletions(-) diff --git a/format.cc b/format.cc index 9aa3fc226078..7d92385ed1ad 100644 --- a/format.cc +++ b/format.cc @@ -395,21 +395,135 @@ class CharConverter : public fmt::internal::ArgVisitor { arg_.int_value = static_cast(value); } }; +} // namespace + +namespace internal { + +template +class BasicArgFormatter : public ArgVisitor { + private: + BasicWriter &writer_; + FormatSpec &spec_; + + FMT_DISALLOW_COPY_AND_ASSIGN(BasicArgFormatter); + + protected: + BasicWriter &writer() { return writer_; } + const FormatSpec &spec() const { return spec_; } -// This function template is used to prevent compile errors when handling -// incompatible string arguments, e.g. handling a wide string in a narrow -// string formatter. + public: + BasicArgFormatter(BasicWriter &w, FormatSpec &s) + : writer_(w), spec_(s) {} + + template + void visit_any_int(T value) { writer_.write_int(value, spec_); } + + template + void visit_any_double(T value) { writer_.write_double(value, spec_); } + + void visit_bool(bool value) { + if (spec_.type_) { + writer_.write_int(value, spec_); + return; + } + const char *str_value = value ? "true" : "false"; + Arg::StringValue str = { str_value, strlen(str_value) }; + writer_.write_str(str, spec_); + } + + void visit_char(int value) { + if (spec_.type_ && spec_.type_ != 'c') { + spec_.flags_ |= CHAR_FLAG; + writer_.write_int(value, spec_); + return; + } + if (spec_.align_ == ALIGN_NUMERIC || spec_.flags_ != 0) + FMT_THROW(FormatError("invalid format specifier for char")); + typedef typename BasicWriter::CharPtr CharPtr; + Char fill = static_cast(spec_.fill()); + CharPtr out = CharPtr(); + if (spec_.width_ > 1) { + out = writer_.grow_buffer(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_.fill_padding(out, spec_.width_, 1, fill); + } else { + std::fill_n(out + 1, spec_.width_ - 1, fill); + } + } else { + out = writer_.grow_buffer(1); + } + *out = static_cast(value); + } + + void visit_string(Arg::StringValue value) { + writer_.write_str(value, spec_); + } + + using ArgVisitor::visit_wstring; + + void visit_wstring(Arg::StringValue value) { + writer_.write_str(value, spec_); + } + + void visit_pointer(const void *value) { + if (spec_.type_ && spec_.type_ != 'p') + report_unknown_type(spec_.type_, "pointer"); + spec_.flags_ = HASH_FLAG; + spec_.type_ = 'x'; + writer_.write_int(reinterpret_cast(value), spec_); + } +}; + +// An argument formatter. template -Arg::StringValue ignore_incompatible_str(Arg::StringValue); +class ArgFormatter : public BasicArgFormatter, Char> { + private: + BasicFormatter &formatter_; + const Char *format_; -template <> -inline Arg::StringValue ignore_incompatible_str( - Arg::StringValue) { return Arg::StringValue(); } + public: + ArgFormatter(BasicFormatter &f, FormatSpec &s, const Char *fmt) + : BasicArgFormatter, Char>(f.writer(), s), + formatter_(f), format_(fmt) {} -template <> -inline Arg::StringValue ignore_incompatible_str( - Arg::StringValue s) { return s; } -} // namespace + void visit_custom(Arg::CustomValue c) { + c.format(&formatter_, c.value, &format_); + } +}; + +template +class PrintfArgFormatter : + public BasicArgFormatter, Char> { + public: + PrintfArgFormatter(BasicWriter &w, FormatSpec &s) + : BasicArgFormatter, Char>(w, s) {} + + void visit_char(int value) { + const FormatSpec &spec = this->spec(); + BasicWriter &writer = this->writer(); + if (spec.type_ && spec.type_ != 'c') + writer.write_int(value, spec); + typedef typename BasicWriter::CharPtr CharPtr; + CharPtr out = CharPtr(); + if (spec.width_ > 1) { + Char fill = ' '; + out = writer.grow_buffer(spec.width_); + if (spec.align_ != ALIGN_LEFT) { + std::fill_n(out, spec.width_ - 1, fill); + out += spec.width_ - 1; + } else { + std::fill_n(out + 1, spec.width_ - 1, fill); + } + } else { + out = writer.grow_buffer(1); + } + *out = static_cast(value); + } +}; +} // namespace internal } // namespace fmt FMT_FUNC void fmt::SystemError::init( @@ -634,89 +748,6 @@ void fmt::internal::ArgMap::init(const ArgList &args) { } } -// An argument formatter. -template -class fmt::internal::ArgFormatter : - public fmt::internal::ArgVisitor, void> { - private: - fmt::BasicFormatter &formatter_; - fmt::BasicWriter &writer_; - fmt::FormatSpec &spec_; - const Char *format_; - - FMT_DISALLOW_COPY_AND_ASSIGN(ArgFormatter); - - public: - ArgFormatter( - fmt::BasicFormatter &f,fmt::FormatSpec &s, const Char *fmt) - : formatter_(f), writer_(f.writer()), spec_(s), format_(fmt) {} - - template - void visit_any_int(T value) { writer_.write_int(value, spec_); } - - template - void visit_any_double(T value) { writer_.write_double(value, spec_); } - - void visit_bool(bool value) { - if (spec_.type_) { - writer_.write_int(value, spec_); - return; - } - const char *str_value = value ? "true" : "false"; - Arg::StringValue str = { str_value, strlen(str_value) }; - writer_.write_str(str, spec_); - } - - void visit_char(int value) { - if (spec_.type_ && spec_.type_ != 'c') { - spec_.flags_ |= CHAR_FLAG; - writer_.write_int(value, spec_); - return; - } - if (spec_.align_ == ALIGN_NUMERIC || spec_.flags_ != 0) - FMT_THROW(FormatError("invalid format specifier for char")); - typedef typename fmt::BasicWriter::CharPtr CharPtr; - Char fill = static_cast(spec_.fill()); - CharPtr out = CharPtr(); - if (spec_.width_ > 1) { - out = writer_.grow_buffer(spec_.width_); - if (spec_.align_ == fmt::ALIGN_RIGHT) { - std::fill_n(out, spec_.width_ - 1, fill); - out += spec_.width_ - 1; - } else if (spec_.align_ == fmt::ALIGN_CENTER) { - out = writer_.fill_padding(out, spec_.width_, 1, fill); - } else { - std::fill_n(out + 1, spec_.width_ - 1, fill); - } - } else { - out = writer_.grow_buffer(1); - } - *out = static_cast(value); - } - - void visit_string(Arg::StringValue value) { - writer_.write_str(value, spec_); - } - - using ArgVisitor, void>::visit_wstring; - - void visit_wstring(Arg::StringValue value) { - writer_.write_str(value, spec_); - } - - void visit_pointer(const void *value) { - if (spec_.type_ && spec_.type_ != 'p') - fmt::internal::report_unknown_type(spec_.type_, "pointer"); - spec_.flags_ = fmt::HASH_FLAG; - spec_.type_ = 'x'; - writer_.write_int(reinterpret_cast(value), spec_); - } - - void visit_custom(Arg::CustomValue c) { - c.format(&formatter_, c.value, &format_); - } -}; - template void fmt::internal::FixedBuffer::grow(std::size_t) { FMT_THROW(std::runtime_error("buffer overflow")); @@ -990,73 +1021,7 @@ void fmt::internal::PrintfFormatter::format( start = s; // Format argument. - switch (arg.type) { - case Arg::INT: - writer.write_int(arg.int_value, spec); - break; - case Arg::UINT: - writer.write_int(arg.uint_value, spec); - break; - case Arg::LONG_LONG: - writer.write_int(arg.long_long_value, spec); - break; - case Arg::ULONG_LONG: - writer.write_int(arg.ulong_long_value, spec); - break; - case Arg::CHAR: { - if (spec.type_ && spec.type_ != 'c') - writer.write_int(arg.int_value, spec); - typedef typename BasicWriter::CharPtr CharPtr; - CharPtr out = CharPtr(); - if (spec.width_ > 1) { - Char fill = ' '; - out = writer.grow_buffer(spec.width_); - if (spec.align_ != ALIGN_LEFT) { - std::fill_n(out, spec.width_ - 1, fill); - out += spec.width_ - 1; - } else { - std::fill_n(out + 1, spec.width_ - 1, fill); - } - } else { - out = writer.grow_buffer(1); - } - *out = static_cast(arg.int_value); - break; - } - case Arg::DOUBLE: - writer.write_double(arg.double_value, spec); - break; - case Arg::LONG_DOUBLE: - writer.write_double(arg.long_double_value, spec); - break; - case Arg::CSTRING: - arg.string.size = 0; - writer.write_str(arg.string, spec); - break; - case Arg::STRING: - writer.write_str(arg.string, spec); - break; - case Arg::WSTRING: - writer.write_str(ignore_incompatible_str(arg.wstring), spec); - break; - case Arg::POINTER: - if (spec.type_ && spec.type_ != 'p') - internal::report_unknown_type(spec.type_, "pointer"); - spec.flags_= HASH_FLAG; - spec.type_ = 'x'; - writer.write_int(reinterpret_cast(arg.pointer), spec); - break; - case Arg::CUSTOM: { - if (spec.type_) - internal::report_unknown_type(spec.type_, "object"); - const void *str_format = "s"; - arg.custom.format(&writer, arg.custom.value, &str_format); - break; - } - default: - assert(false); - break; - } + internal::PrintfArgFormatter(writer, spec).visit(arg); } write(writer, start, s); } diff --git a/format.h b/format.h index ce8a7bc6c351..30d1b4e09fd2 100644 --- a/format.h +++ b/format.h @@ -1120,8 +1120,11 @@ class RuntimeError : public std::runtime_error { RuntimeError() : std::runtime_error("") {} }; +template +class BasicArgFormatter; + template -class ArgFormatter; +class PrintfArgFormatter; template class ArgMap; @@ -1857,8 +1860,10 @@ class BasicWriter { template void append_float_length(Char *&, T) {} - friend class internal::ArgFormatter; - friend class internal::PrintfFormatter; + template + friend class internal::BasicArgFormatter; + + friend class internal::PrintfArgFormatter; protected: /**