X-Git-Url: http://plrg.eecs.uci.edu/git/?a=blobdiff_plain;f=folly%2FFormat-inl.h;h=5331bbba199038caed2cae4e9104ebcb40d5fe1e;hb=8b05be27769e2e3d5d1681251953506c22f76b45;hp=bba7be85ed588e310412f70054f7e1c407c3dfb0;hpb=86d219c38847965714df9eba03b07fa2f6e30ecc;p=folly.git diff --git a/folly/Format-inl.h b/folly/Format-inl.h index bba7be85..5331bbba 100644 --- a/folly/Format-inl.h +++ b/folly/Format-inl.h @@ -1,5 +1,5 @@ /* - * Copyright 2013 Facebook, Inc. + * Copyright 2014 Facebook, Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -18,6 +18,13 @@ #error This file may only be included from Format.h. #endif +#include +#include + +// Ignore -Wformat-nonliteral warnings within this file +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wformat-nonliteral" + namespace folly { namespace detail { @@ -45,7 +52,7 @@ size_t uintToHex(char* buffer, size_t bufLen, Uint v, const char (&repr)[256][2]) { // 'v >>= 7, v >>= 1' is no more than a work around to get rid of shift size // warning when Uint = uint8_t (it's false as v >= 256 implies sizeof(v) > 1). - for (; v >= 256; v >>= 7, v >>= 1) { + for (; !less_than(v); v >>= 7, v >>= 1) { auto b = v & 0xff; bufLen -= 2; buffer[bufLen] = repr[b][0]; @@ -89,7 +96,7 @@ size_t uintToOctal(char* buffer, size_t bufLen, Uint v) { auto& repr = formatOctal; // 'v >>= 7, v >>= 2' is no more than a work around to get rid of shift size // warning when Uint = uint8_t (it's false as v >= 512 implies sizeof(v) > 1). - for (; v >= 512; v >>= 7, v >>= 2) { + for (; !less_than(v); v >>= 7, v >>= 2) { auto b = v & 0x1ff; bufLen -= 3; buffer[bufLen] = repr[b][0]; @@ -134,19 +141,64 @@ size_t uintToBinary(char* buffer, size_t bufLen, Uint v) { } // namespace detail - -template -Formatter::Formatter(StringPiece str, Args&&... args) - : str_(str), - values_(FormatValue::type>( - std::forward(args))...) { +template +BaseFormatter::BaseFormatter(StringPiece str, + Args&&... args) + : str_(str), + values_(FormatValue::type>( + std::forward(args))...) { static_assert(!containerMode || sizeof...(Args) == 1, "Exactly one argument required in container mode"); } -template +template +void BaseFormatter::handleFormatStrError() + const { + if (crashOnError_) { + LOG(FATAL) << "folly::format: bad format string \"" << str_ << "\": " << + folly::exceptionStr(std::current_exception()); + } + throw; +} + +template template -void Formatter::operator()(Output& out) const { +void BaseFormatter::operator()(Output& out) + const { + // Catch BadFormatArg and range_error exceptions, and call + // handleFormatStrError(). + // + // These exception types indicate a problem with the format string. Most + // format strings are string literals specified by the programmer. If they + // have a problem, this is usually a programmer bug. We want to crash to + // ensure that these are found early on during development. + // + // BadFormatArg is thrown by the Format.h code, while range_error is thrown + // by Conv.h, which is used in several places in our format string + // processing. + // + // (Note: This behavior is slightly dangerous. If the Output object throws a + // BadFormatArg or a range_error, we will also crash the program, even if it + // wasn't an issue with the format string. This seems highly unlikely + // though, and none of our current Output objects can throw these errors.) + // + // We also throw out_of_range errors if the format string references an + // argument that isn't present (or a key that isn't present in one of the + // argument containers). However, at the moment we don't crash on these + // errors, as it is likely that the container is dynamic at runtime. + try { + appendOutput(out); + } catch (const BadFormatArg& ex) { + handleFormatStrError(); + } catch (const std::range_error& ex) { + handleFormatStrError(); + } +} + +template +template +void BaseFormatter::appendOutput(Output& out) + const { auto p = str_.begin(); auto end = str_.end(); @@ -167,8 +219,7 @@ void Formatter::operator()(Output& out) const { p = q; if (p == end || *p != '}') { - throw std::invalid_argument( - "folly::format: single '}' in format string"); + throw BadFormatArg("folly::format: single '}' in format string"); } ++p; } @@ -187,8 +238,7 @@ void Formatter::operator()(Output& out) const { p = q + 1; if (p == end) { - throw std::invalid_argument( - "folly::format: '}' at end of format string"); + throw BadFormatArg("folly::format: '}' at end of format string"); } // "{{" -> "{" @@ -200,8 +250,8 @@ void Formatter::operator()(Output& out) const { // Format string q = static_cast(memchr(p, '}', end - p)); - if (q == end) { - throw std::invalid_argument("folly::format: missing ending '}'"); + if (q == nullptr) { + throw BadFormatArg("folly::format: missing ending '}'"); } FormatArg arg(StringPiece(p, q)); p = q + 1; @@ -232,7 +282,7 @@ void Formatter::operator()(Output& out) const { } if (hasDefaultArgIndex && hasExplicitArgIndex) { - throw std::invalid_argument( + throw BadFormatArg( "folly::format: may not have both default and explicit arg indexes"); } @@ -240,12 +290,35 @@ void Formatter::operator()(Output& out) const { } } +template +void writeTo(FILE* fp, + const BaseFormatter& formatter) { + auto writer = [fp] (StringPiece sp) { + ssize_t n = fwrite(sp.data(), 1, sp.size(), fp); + if (n < sp.size()) { + throwSystemError("Formatter writeTo", "fwrite failed"); + } + }; + formatter(writer); +} + namespace format_value { template void formatString(StringPiece val, FormatArg& arg, FormatCallback& cb) { + if (arg.width != FormatArg::kDefaultWidth && arg.width < 0) { + throw BadFormatArg("folly::format: invalid width"); + } + if (arg.precision != FormatArg::kDefaultPrecision && arg.precision < 0) { + throw BadFormatArg("folly::format: invalid precision"); + } + + // XXX: clang should be smart enough to not need the two static_cast + // uses below given the above checks. If clang ever becomes that smart, we + // should remove the otherwise unnecessary warts. + if (arg.precision != FormatArg::kDefaultPrecision && - val.size() > arg.precision) { + val.size() > static_cast(arg.precision)) { val.reset(val.data(), arg.precision); } @@ -262,9 +335,10 @@ void formatString(StringPiece val, FormatArg& arg, FormatCallback& cb) { }; int padRemaining = 0; - if (arg.width != FormatArg::kDefaultWidth && val.size() < arg.width) { + if (arg.width != FormatArg::kDefaultWidth && + val.size() < static_cast(arg.width)) { char fill = arg.fill == FormatArg::kDefaultFill ? ' ' : arg.fill; - int padChars = arg.width - val.size(); + int padChars = static_cast (arg.width - val.size()); memset(padBuf, fill, std::min(padBufSize, padChars)); switch (arg.align) { @@ -309,10 +383,14 @@ void formatNumber(StringPiece val, int prefixLen, FormatArg& arg, format_value::formatString(val, arg, cb); } -template -void formatFormatter(const Formatter& formatter, - FormatArg& arg, - FormatCallback& cb) { +template +void formatFormatter( + const BaseFormatter& formatter, + FormatArg& arg, + FormatCallback& cb) { if (arg.width == FormatArg::kDefaultWidth && arg.precision == FormatArg::kDefaultPrecision) { // nothing to do @@ -377,7 +455,7 @@ class FormatValue< UT uval; char sign; if (std::is_signed::value) { - if (val_ < 0) { + if (folly::is_negative(val_)) { uval = static_cast(-val_); sign = '-'; } else { @@ -562,15 +640,13 @@ class FormatValue { arg.precision = 6; } - bool done = false; - // 2+: for null terminator and optional sign shenanigans. char buf[2 + std::max({ (2 + DoubleToStringConverter::kMaxFixedDigitsBeforePoint + DoubleToStringConverter::kMaxFixedDigitsAfterPoint), (8 + DoubleToStringConverter::kMaxExponentialDigits), (7 + DoubleToStringConverter::kMaxPrecisionDigits)})]; - StringBuilder builder(buf + 1, sizeof(buf) - 1); + StringBuilder builder(buf + 1, static_cast (sizeof(buf) - 1)); char plusSign; switch (arg.sign) { @@ -585,6 +661,11 @@ class FormatValue { break; }; + auto flags = + DoubleToStringConverter::EMIT_POSITIVE_EXPONENT_SIGN | + (arg.trailingDot ? DoubleToStringConverter::EMIT_TRAILING_DECIMAL_POINT + : 0); + double val = val_; switch (arg.presentation) { case '%': @@ -596,13 +677,14 @@ class FormatValue { DoubleToStringConverter::kMaxFixedDigitsAfterPoint) { arg.precision = DoubleToStringConverter::kMaxFixedDigitsAfterPoint; } - DoubleToStringConverter conv( - DoubleToStringConverter::EMIT_POSITIVE_EXPONENT_SIGN, - infinitySymbol, - nanSymbol, - exponentSymbol, - -4, arg.precision, - 0, 0); + DoubleToStringConverter conv(flags, + infinitySymbol, + nanSymbol, + exponentSymbol, + -4, + arg.precision, + 0, + 0); arg.enforce(conv.ToFixed(val, arg.precision, &builder), "fixed double conversion failed"); } @@ -614,14 +696,15 @@ class FormatValue { arg.precision = DoubleToStringConverter::kMaxExponentialDigits; } - DoubleToStringConverter conv( - DoubleToStringConverter::EMIT_POSITIVE_EXPONENT_SIGN, - infinitySymbol, - nanSymbol, - exponentSymbol, - -4, arg.precision, - 0, 0); - CHECK(conv.ToExponential(val, arg.precision, &builder)); + DoubleToStringConverter conv(flags, + infinitySymbol, + nanSymbol, + exponentSymbol, + -4, + arg.precision, + 0, + 0); + arg.enforce(conv.ToExponential(val, arg.precision, &builder)); } break; case 'n': // should be locale-aware, but isn't @@ -634,14 +717,15 @@ class FormatValue { DoubleToStringConverter::kMaxPrecisionDigits) { arg.precision = DoubleToStringConverter::kMaxPrecisionDigits; } - DoubleToStringConverter conv( - DoubleToStringConverter::EMIT_POSITIVE_EXPONENT_SIGN, - infinitySymbol, - nanSymbol, - exponentSymbol, - -4, arg.precision, - 0, 0); - CHECK(conv.ToShortest(val, &builder)); + DoubleToStringConverter conv(flags, + infinitySymbol, + nanSymbol, + exponentSymbol, + -4, + arg.precision, + 0, + 0); + arg.enforce(conv.ToShortest(val, &builder)); } break; default: @@ -856,6 +940,11 @@ struct IndexableTraitsSeq : public FormatTraitsBase { static const value_type& at(const C& c, int idx) { return c.at(idx); } + + static const value_type& at(const C& c, int idx, + const value_type& dflt) { + return (idx >= 0 && idx < c.size()) ? c.at(idx) : dflt; + } }; // Base class for associative types (maps) @@ -865,6 +954,11 @@ struct IndexableTraitsAssoc : public FormatTraitsBase { static const value_type& at(const C& c, int idx) { return c.at(static_cast(idx)); } + static const value_type& at(const C& c, int idx, + const value_type& dflt) { + auto pos = c.find(static_cast(idx)); + return pos != c.end() ? pos->second : dflt; + } }; // std::array @@ -935,6 +1029,28 @@ class FormatValue< const T& val_; }; +template +class FormatValue< + detail::DefaultValueWrapper, + typename detail::IndexableTraits::enabled> { + public: + explicit FormatValue(const detail::DefaultValueWrapper& val) + : val_(val) { } + + template + void format(FormatArg& arg, FormatCallback& cb) const { + FormatValue::value_type>::type>( + detail::IndexableTraits::at( + val_.container, + arg.splitIntKey(), + val_.defaultValue)).format(arg, cb); + } + + private: + const detail::DefaultValueWrapper& val_; +}; + namespace detail { // Define enabled, key_type, convert from StringPiece to the key types @@ -976,6 +1092,11 @@ template struct KeyableTraitsAssoc : public FormatTraitsBase { static const value_type& at(const T& map, StringPiece key) { return map.at(KeyFromStringPiece::convert(key)); } + static const value_type& at(const T& map, StringPiece key, + const value_type& dflt) { + auto pos = map.find(KeyFromStringPiece::convert(key)); + return pos != map.end() ? pos->second : dflt; + } }; // Define enabled, key_type, value_type, at() for supported string-keyed @@ -1020,6 +1141,28 @@ class FormatValue< const T& val_; }; +template +class FormatValue< + detail::DefaultValueWrapper, + typename detail::KeyableTraits::enabled> { + public: + explicit FormatValue(const detail::DefaultValueWrapper& val) + : val_(val) { } + + template + void format(FormatArg& arg, FormatCallback& cb) const { + FormatValue::value_type>::type>( + detail::KeyableTraits::at( + val_.container, + arg.splitKey(), + val_.defaultValue)).format(arg, cb); + } + + private: + const detail::DefaultValueWrapper& val_; +}; + // Partial specialization of FormatValue for pairs template class FormatValue> { @@ -1089,9 +1232,13 @@ class FormatValue> { }; // Partial specialization of FormatValue for nested Formatters -template -class FormatValue, void> { - typedef Formatter FormatterValue; +template class F> +class FormatValue, + typename std::enable_if>::value>::type> { + typedef typename F::BaseType FormatterValue; + public: explicit FormatValue(const FormatterValue& f) : f_(f) { } @@ -1107,11 +1254,12 @@ class FormatValue, void> { * Formatter objects can be appended to strings, and therefore they're * compatible with folly::toAppend and folly::to. */ -template -typename std::enable_if< - detail::IsSomeString::value>::type -toAppend(const Formatter& value, Tgt * result) { +template +typename std::enable_if::value>::type toAppend( + const BaseFormatter& value, Tgt* result) { value.appendTo(*result); } } // namespace folly + +#pragma GCC diagnostic pop