X-Git-Url: http://plrg.eecs.uci.edu/git/?a=blobdiff_plain;f=folly%2FFormat-inl.h;h=f05a5c723331edf0649d878900d54ebb1c212af5;hb=6fc7a48c7e3a5cdb0c97196b2ff0f08c6ee073d7;hp=831d3c82149a5420f9c073ff3bc0583bfc3d62e2;hpb=378a3bbc7ec5298f92f8c43083c2b0f7836348a6;p=folly.git diff --git a/folly/Format-inl.h b/folly/Format-inl.h index 831d3c82..f05a5c72 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,6 +290,18 @@ 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 @@ -264,7 +326,7 @@ void formatString(StringPiece val, FormatArg& arg, FormatCallback& cb) { int padRemaining = 0; if (arg.width != FormatArg::kDefaultWidth && val.size() < 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 +371,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 @@ -562,15 +628,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 +649,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 +665,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 +684,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 +705,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 +928,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 +942,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 +1017,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 +1080,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 +1129,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 +1220,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 +1242,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