X-Git-Url: http://plrg.eecs.uci.edu/git/?a=blobdiff_plain;f=folly%2FFormat-inl.h;h=6205a5682eb6e7a09c3fa124bc1913ba967e2a04;hb=36ca845043259977fac1e8cddec7427d711e1126;hp=79ea1f7915bb040a24879f4c6feacac093a89fc6;hpb=c2c66129648524ddb456fa44b35c1531dd103004;p=folly.git diff --git a/folly/Format-inl.h b/folly/Format-inl.h index 79ea1f79..6205a568 100644 --- a/folly/Format-inl.h +++ b/folly/Format-inl.h @@ -1,5 +1,5 @@ /* - * Copyright 2014 Facebook, Inc. + * Copyright 2015 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,8 +18,8 @@ #error This file may only be included from Format.h. #endif -#include "folly/Exception.h" -#include "folly/Traits.h" +#include +#include // Ignore -Wformat-nonliteral warnings within this file #pragma GCC diagnostic push @@ -29,6 +29,9 @@ namespace folly { namespace detail { +// Updates the end of the buffer after the comma separators have been added. +void insertThousandsGroupingUnsafe(char* start_buffer, char** end_buffer); + extern const char formatHexUpper[256][2]; extern const char formatHexLower[256][2]; extern const char formatOctal[512][3]; @@ -141,64 +144,20 @@ 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 -void Formatter::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 { - // 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 template -void Formatter::appendOutput(Output& out) const { - auto p = str_.begin(); - auto end = str_.end(); - +void BaseFormatter::operator()(Output& out) + const { // Copy raw string (without format specifiers) to output; // not as simple as we'd like, as we still need to translate "}}" to "}" // and throw if we see any lone "}" @@ -222,6 +181,9 @@ void Formatter::appendOutput(Output& out) const { } }; + auto p = str_.begin(); + auto end = str_.end(); + int nextArg = 0; bool hasDefaultArgIndex = false; bool hasExplicitArgIndex = false; @@ -287,10 +249,11 @@ void Formatter::appendOutput(Output& out) const { } } -template -void writeTo(FILE* fp, const Formatter& formatter) { +template +void writeTo(FILE* fp, + const BaseFormatter& formatter) { auto writer = [fp] (StringPiece sp) { - ssize_t n = fwrite(sp.data(), 1, sp.size(), fp); + size_t n = fwrite(sp.data(), 1, sp.size(), fp); if (n < sp.size()) { throwSystemError("Formatter writeTo", "fwrite failed"); } @@ -302,8 +265,19 @@ 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); } @@ -320,9 +294,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) { @@ -367,10 +342,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 @@ -472,27 +451,36 @@ class FormatValue< char* valBufBegin = nullptr; char* valBufEnd = nullptr; - // Defer to sprintf - auto useSprintf = [&] (const char* format) mutable { - valBufBegin = valBuf + 3; // room for sign and base prefix - valBufEnd = valBufBegin + sprintf(valBufBegin, format, - static_cast(uval)); - }; - int prefixLen = 0; - switch (presentation) { - case 'n': // TODO(tudorb): locale awareness? + case 'n': { + arg.enforce(!arg.basePrefix, + "base prefix not allowed with '", presentation, + "' specifier"); + + arg.enforce(!arg.thousandsSeparator, + "cannot use ',' with the '", presentation, + "' specifier"); + + valBufBegin = valBuf + 3; // room for sign and base prefix + int len = snprintf(valBufBegin, (valBuf + valBufSize) - valBufBegin, + "%'ju", static_cast(uval)); + // valBufSize should always be big enough, so this should never + // happen. + assert(len < valBuf + valBufSize - valBufBegin); + valBufEnd = valBufBegin + len; + break; + } case 'd': arg.enforce(!arg.basePrefix, "base prefix not allowed with '", presentation, "' specifier"); + valBufBegin = valBuf + 3; // room for sign and base prefix + + // Use uintToBuffer, faster than sprintf + valBufEnd = valBufBegin + uint64ToBufferUnsafe(uval, valBufBegin); if (arg.thousandsSeparator) { - useSprintf("%'ju"); - } else { - // Use uintToBuffer, faster than sprintf - valBufBegin = valBuf + 3; - valBufEnd = valBufBegin + uint64ToBufferUnsafe(uval, valBufBegin); + detail::insertThousandsGroupingUnsafe(valBufBegin, &valBufEnd); } break; case 'c': @@ -603,127 +591,15 @@ class FormatValue { template void format(FormatArg& arg, FormatCallback& cb) const { - using ::double_conversion::DoubleToStringConverter; - using ::double_conversion::StringBuilder; - - arg.validate(FormatArg::Type::FLOAT); - - if (arg.presentation == FormatArg::kDefaultPresentation) { - arg.presentation = 'g'; - } - - const char* infinitySymbol = isupper(arg.presentation) ? "INF" : "inf"; - const char* nanSymbol = isupper(arg.presentation) ? "NAN" : "nan"; - char exponentSymbol = isupper(arg.presentation) ? 'E' : 'e'; - - if (arg.precision == FormatArg::kDefaultPrecision) { - arg.precision = 6; - } - - // 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); - - char plusSign; - switch (arg.sign) { - case FormatArg::Sign::PLUS_OR_MINUS: - plusSign = '+'; - break; - case FormatArg::Sign::SPACE_OR_MINUS: - plusSign = ' '; - break; - default: - plusSign = '\0'; - break; - }; - - double val = val_; - switch (arg.presentation) { - case '%': - val *= 100; - case 'f': - case 'F': - { - if (arg.precision > - DoubleToStringConverter::kMaxFixedDigitsAfterPoint) { - arg.precision = DoubleToStringConverter::kMaxFixedDigitsAfterPoint; - } - DoubleToStringConverter conv( - DoubleToStringConverter::EMIT_POSITIVE_EXPONENT_SIGN, - infinitySymbol, - nanSymbol, - exponentSymbol, - -4, arg.precision, - 0, 0); - arg.enforce(conv.ToFixed(val, arg.precision, &builder), - "fixed double conversion failed"); - } - break; - case 'e': - case 'E': - { - if (arg.precision > DoubleToStringConverter::kMaxExponentialDigits) { - arg.precision = DoubleToStringConverter::kMaxExponentialDigits; - } - - DoubleToStringConverter conv( - DoubleToStringConverter::EMIT_POSITIVE_EXPONENT_SIGN, - 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 - case 'g': - case 'G': - { - if (arg.precision < DoubleToStringConverter::kMinPrecisionDigits) { - arg.precision = DoubleToStringConverter::kMinPrecisionDigits; - } else if (arg.precision > - DoubleToStringConverter::kMaxPrecisionDigits) { - arg.precision = DoubleToStringConverter::kMaxPrecisionDigits; - } - DoubleToStringConverter conv( - DoubleToStringConverter::EMIT_POSITIVE_EXPONENT_SIGN, - infinitySymbol, - nanSymbol, - exponentSymbol, - -4, arg.precision, - 0, 0); - arg.enforce(conv.ToShortest(val, &builder)); - } - break; - default: - arg.error("invalid specifier '", arg.presentation, "'"); - } - - int len = builder.position(); - builder.Finalize(); - DCHECK_GT(len, 0); - - // Add '+' or ' ' sign if needed - char* p = buf + 1; - // anything that's neither negative nor nan - int prefixLen = 0; - if (plusSign && (*p != '-' && *p != 'n' && *p != 'N')) { - *--p = plusSign; - ++len; - prefixLen = 1; - } else if (*p == '-') { - prefixLen = 1; - } - - format_value::formatNumber(StringPiece(p, len), prefixLen, arg, cb); + fbstring piece; + int prefixLen; + formatHelper(piece, prefixLen, arg); + format_value::formatNumber(piece, prefixLen, arg, cb); } private: + void formatHelper(fbstring& piece, int& prefixLen, FormatArg& arg) const; + double val_; }; @@ -915,7 +791,7 @@ struct IndexableTraitsSeq : public FormatTraitsBase { static const value_type& at(const C& c, int idx, const value_type& dflt) { - return (idx >= 0 && idx < c.size()) ? c.at(idx) : dflt; + return (idx >= 0 && size_t(idx) < c.size()) ? c.at(idx) : dflt; } }; @@ -1204,9 +1080,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) { } @@ -1222,10 +1102,9 @@ 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< - 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); }