ca9856cabc
-- 53550735f5a943dfb99225e7c53f211c2d6e7951 by Gennadiy Rozental <rogeeff@google.com>: Import of CCTZ from GitHub. PiperOrigin-RevId: 309333648 -- 847bbf8a1d9cd322ec058c6f932d1f687fd3d331 by Gennadiy Rozental <rogeeff@google.com>: Make Validation interfaces private in CommandLineFlag. Calls are rewired via private interface access struct. PiperOrigin-RevId: 309323013 -- a600fc5051e0a0af50a7850450fd3ed1aef3f316 by Matthew Brown <matthewbr@google.com>: Internal Change. PiperOrigin-RevId: 309292207 -- 937d00ce3cf62c5f23f59b5377471fd01d6bfbc7 by Gennadiy Rozental <rogeeff@google.com>: Make TypeId interface private in CommandLineFlag. We also rewire the SaveState via the new PrivateHandleInterface trampoline class. This class will be the only way to access private methods of class CommandLineFlag. PiperOrigin-RevId: 309282547 -- 796c4bd35073b6a8337762bdb13603dae12a4df1 by Derek Mauro <dmauro@google.com>: Cleanup uses of kLinkerInitialized PiperOrigin-RevId: 309274734 -- c831446c52d9ef4bdcb1ea369840904620abc4b9 by Gennadiy Rozental <rogeeff@google.com>: Eliminate the interface IsModified of CommndLineFlag. PiperOrigin-RevId: 309256248 -- a1db59d7f7aa39cb0a37dbf80f8c04e371da8465 by Gennadiy Rozental <rogeeff@google.com>: Avoid default value generator if default value expression is constexpr. If possible, we detect constexpr-ness of default value expression and avoid storing default value generator in side of flag and instead set the flag's value to the value of that expression at const initialization time of flag objects. At the moment we only do this for flags of (all) integral, float and double value types PiperOrigin-RevId: 309110630 -- ae3b4a139aacd8fc165c9acd2a3cbae1f9e26af4 by Gennadiy Rozental <rogeeff@google.com>: Make SaveState a private method of the CommandLineFlag and make it only accessible from FlagSaverImpl. There is no other call sites for this call. PiperOrigin-RevId: 309073989 -- cbc24b4dcc166dd6b0208e9d7620484eaaaa7ee0 by Abseil Team <absl-team@google.com>: Eliminate the interface IsModified of CommndLineFlag. PiperOrigin-RevId: 309064639 -- 08e79645a89d71785c5381cea9c413357db9824a by Gennadiy Rozental <rogeeff@google.com>: Eliminate the interface IsModified of CommndLineFlag. PiperOrigin-RevId: 309054430 -- 4a6c70233c60dc8c39b7fa9beb5fa687c215261f by Gennadiy Rozental <rogeeff@google.com>: Internal change PiperOrigin-RevId: 308900784 -- 13160efdf7710f142778d5a1e4c85aa309f019b6 by Abseil Team <absl-team@google.com>: Provide definitions of static member variables -- improved C++11 support. PiperOrigin-RevId: 308900290 -- 0343b8228657b9b313afdfe88c4a7b2137d56db4 by Gennadiy Rozental <rogeeff@google.com>: Rename method Get<T> to TryGet<T> per approved spec before making interface public. PiperOrigin-RevId: 308889113 -- 7b84e27fb857fc1296a05504970f506d47d2f2c1 by Derek Mauro <dmauro@google.com>: Remove node_hash_* methods that were deprecated on release PiperOrigin-RevId: 308837933 -- 599d44ee72c02b6bb6e1c1a1db72873841441416 by Gennadiy Rozental <rogeeff@google.com>: Eliminate CommandLineFlag::Typename interface per approved spec before making CommandLineFlag public. PiperOrigin-RevId: 308814376 GitOrigin-RevId: 53550735f5a943dfb99225e7c53f211c2d6e7951 Change-Id: Iae52c65b7322152c7e58f222d60eb5a21699a2cb
460 lines
15 KiB
C++
460 lines
15 KiB
C++
//
|
|
// POSIX spec:
|
|
// http://pubs.opengroup.org/onlinepubs/009695399/functions/fprintf.html
|
|
//
|
|
#include "absl/strings/internal/str_format/arg.h"
|
|
|
|
#include <cassert>
|
|
#include <cerrno>
|
|
#include <cstdlib>
|
|
#include <string>
|
|
#include <type_traits>
|
|
|
|
#include "absl/base/port.h"
|
|
#include "absl/strings/internal/str_format/float_conversion.h"
|
|
#include "absl/strings/numbers.h"
|
|
|
|
namespace absl {
|
|
ABSL_NAMESPACE_BEGIN
|
|
namespace str_format_internal {
|
|
namespace {
|
|
|
|
// Reduce *capacity by s.size(), clipped to a 0 minimum.
|
|
void ReducePadding(string_view s, size_t *capacity) {
|
|
*capacity = Excess(s.size(), *capacity);
|
|
}
|
|
|
|
// Reduce *capacity by n, clipped to a 0 minimum.
|
|
void ReducePadding(size_t n, size_t *capacity) {
|
|
*capacity = Excess(n, *capacity);
|
|
}
|
|
|
|
template <typename T>
|
|
struct MakeUnsigned : std::make_unsigned<T> {};
|
|
template <>
|
|
struct MakeUnsigned<absl::int128> {
|
|
using type = absl::uint128;
|
|
};
|
|
template <>
|
|
struct MakeUnsigned<absl::uint128> {
|
|
using type = absl::uint128;
|
|
};
|
|
|
|
template <typename T>
|
|
struct IsSigned : std::is_signed<T> {};
|
|
template <>
|
|
struct IsSigned<absl::int128> : std::true_type {};
|
|
template <>
|
|
struct IsSigned<absl::uint128> : std::false_type {};
|
|
|
|
// Integral digit printer.
|
|
// Call one of the PrintAs* routines after construction once.
|
|
// Use with_neg_and_zero/without_neg_or_zero/is_negative to access the results.
|
|
class IntDigits {
|
|
public:
|
|
// Print the unsigned integer as octal.
|
|
// Supports unsigned integral types and uint128.
|
|
template <typename T>
|
|
void PrintAsOct(T v) {
|
|
static_assert(!IsSigned<T>::value, "");
|
|
char *p = storage_ + sizeof(storage_);
|
|
do {
|
|
*--p = static_cast<char>('0' + (static_cast<size_t>(v) & 7));
|
|
v >>= 3;
|
|
} while (v);
|
|
start_ = p;
|
|
size_ = storage_ + sizeof(storage_) - p;
|
|
}
|
|
|
|
// Print the signed or unsigned integer as decimal.
|
|
// Supports all integral types.
|
|
template <typename T>
|
|
void PrintAsDec(T v) {
|
|
static_assert(std::is_integral<T>::value, "");
|
|
start_ = storage_;
|
|
size_ = numbers_internal::FastIntToBuffer(v, storage_) - storage_;
|
|
}
|
|
|
|
void PrintAsDec(int128 v) {
|
|
auto u = static_cast<uint128>(v);
|
|
bool add_neg = false;
|
|
if (v < 0) {
|
|
add_neg = true;
|
|
u = uint128{} - u;
|
|
}
|
|
PrintAsDec(u, add_neg);
|
|
}
|
|
|
|
void PrintAsDec(uint128 v, bool add_neg = false) {
|
|
// This function can be sped up if needed. We can call FastIntToBuffer
|
|
// twice, or fix FastIntToBuffer to support uint128.
|
|
char *p = storage_ + sizeof(storage_);
|
|
do {
|
|
p -= 2;
|
|
numbers_internal::PutTwoDigits(static_cast<size_t>(v % 100), p);
|
|
v /= 100;
|
|
} while (v);
|
|
if (p[0] == '0') {
|
|
// We printed one too many hexits.
|
|
++p;
|
|
}
|
|
if (add_neg) {
|
|
*--p = '-';
|
|
}
|
|
size_ = storage_ + sizeof(storage_) - p;
|
|
start_ = p;
|
|
}
|
|
|
|
// Print the unsigned integer as hex using lowercase.
|
|
// Supports unsigned integral types and uint128.
|
|
template <typename T>
|
|
void PrintAsHexLower(T v) {
|
|
static_assert(!IsSigned<T>::value, "");
|
|
char *p = storage_ + sizeof(storage_);
|
|
|
|
do {
|
|
p -= 2;
|
|
constexpr const char* table = numbers_internal::kHexTable;
|
|
std::memcpy(p, table + 2 * (static_cast<size_t>(v) & 0xFF), 2);
|
|
if (sizeof(T) == 1) break;
|
|
v >>= 8;
|
|
} while (v);
|
|
if (p[0] == '0') {
|
|
// We printed one too many digits.
|
|
++p;
|
|
}
|
|
start_ = p;
|
|
size_ = storage_ + sizeof(storage_) - p;
|
|
}
|
|
|
|
// Print the unsigned integer as hex using uppercase.
|
|
// Supports unsigned integral types and uint128.
|
|
template <typename T>
|
|
void PrintAsHexUpper(T v) {
|
|
static_assert(!IsSigned<T>::value, "");
|
|
char *p = storage_ + sizeof(storage_);
|
|
|
|
// kHexTable is only lowercase, so do it manually for uppercase.
|
|
do {
|
|
*--p = "0123456789ABCDEF"[static_cast<size_t>(v) & 15];
|
|
v >>= 4;
|
|
} while (v);
|
|
start_ = p;
|
|
size_ = storage_ + sizeof(storage_) - p;
|
|
}
|
|
|
|
// The printed value including the '-' sign if available.
|
|
// For inputs of value `0`, this will return "0"
|
|
string_view with_neg_and_zero() const { return {start_, size_}; }
|
|
|
|
// The printed value not including the '-' sign.
|
|
// For inputs of value `0`, this will return "".
|
|
string_view without_neg_or_zero() const {
|
|
static_assert('-' < '0', "The check below verifies both.");
|
|
size_t advance = start_[0] <= '0' ? 1 : 0;
|
|
return {start_ + advance, size_ - advance};
|
|
}
|
|
|
|
bool is_negative() const { return start_[0] == '-'; }
|
|
|
|
private:
|
|
const char *start_;
|
|
size_t size_;
|
|
// Max size: 128 bit value as octal -> 43 digits, plus sign char
|
|
char storage_[128 / 3 + 1 + 1];
|
|
};
|
|
|
|
// Note: 'o' conversions do not have a base indicator, it's just that
|
|
// the '#' flag is specified to modify the precision for 'o' conversions.
|
|
string_view BaseIndicator(const IntDigits &as_digits,
|
|
const ConversionSpec conv) {
|
|
// always show 0x for %p.
|
|
bool alt = conv.has_alt_flag() || conv.conversion_char() == ConversionChar::p;
|
|
bool hex = (conv.conversion_char() == FormatConversionChar::x ||
|
|
conv.conversion_char() == FormatConversionChar::X ||
|
|
conv.conversion_char() == FormatConversionChar::p);
|
|
// From the POSIX description of '#' flag:
|
|
// "For x or X conversion specifiers, a non-zero result shall have
|
|
// 0x (or 0X) prefixed to it."
|
|
if (alt && hex && !as_digits.without_neg_or_zero().empty()) {
|
|
return conv.conversion_char() == FormatConversionChar::X ? "0X" : "0x";
|
|
}
|
|
return {};
|
|
}
|
|
|
|
string_view SignColumn(bool neg, const ConversionSpec conv) {
|
|
if (conv.conversion_char() == FormatConversionChar::d ||
|
|
conv.conversion_char() == FormatConversionChar::i) {
|
|
if (neg) return "-";
|
|
if (conv.has_show_pos_flag()) return "+";
|
|
if (conv.has_sign_col_flag()) return " ";
|
|
}
|
|
return {};
|
|
}
|
|
|
|
bool ConvertCharImpl(unsigned char v, const ConversionSpec conv,
|
|
FormatSinkImpl *sink) {
|
|
size_t fill = 0;
|
|
if (conv.width() >= 0) fill = conv.width();
|
|
ReducePadding(1, &fill);
|
|
if (!conv.has_left_flag()) sink->Append(fill, ' ');
|
|
sink->Append(1, v);
|
|
if (conv.has_left_flag()) sink->Append(fill, ' ');
|
|
return true;
|
|
}
|
|
|
|
bool ConvertIntImplInnerSlow(const IntDigits &as_digits,
|
|
const ConversionSpec conv, FormatSinkImpl *sink) {
|
|
// Print as a sequence of Substrings:
|
|
// [left_spaces][sign][base_indicator][zeroes][formatted][right_spaces]
|
|
size_t fill = 0;
|
|
if (conv.width() >= 0) fill = conv.width();
|
|
|
|
string_view formatted = as_digits.without_neg_or_zero();
|
|
ReducePadding(formatted, &fill);
|
|
|
|
string_view sign = SignColumn(as_digits.is_negative(), conv);
|
|
ReducePadding(sign, &fill);
|
|
|
|
string_view base_indicator = BaseIndicator(as_digits, conv);
|
|
ReducePadding(base_indicator, &fill);
|
|
|
|
int precision = conv.precision();
|
|
bool precision_specified = precision >= 0;
|
|
if (!precision_specified)
|
|
precision = 1;
|
|
|
|
if (conv.has_alt_flag() && conv.conversion_char() == ConversionChar::o) {
|
|
// From POSIX description of the '#' (alt) flag:
|
|
// "For o conversion, it increases the precision (if necessary) to
|
|
// force the first digit of the result to be zero."
|
|
if (formatted.empty() || *formatted.begin() != '0') {
|
|
int needed = static_cast<int>(formatted.size()) + 1;
|
|
precision = std::max(precision, needed);
|
|
}
|
|
}
|
|
|
|
size_t num_zeroes = Excess(formatted.size(), precision);
|
|
ReducePadding(num_zeroes, &fill);
|
|
|
|
size_t num_left_spaces = !conv.has_left_flag() ? fill : 0;
|
|
size_t num_right_spaces = conv.has_left_flag() ? fill : 0;
|
|
|
|
// From POSIX description of the '0' (zero) flag:
|
|
// "For d, i, o, u, x, and X conversion specifiers, if a precision
|
|
// is specified, the '0' flag is ignored."
|
|
if (!precision_specified && conv.has_zero_flag()) {
|
|
num_zeroes += num_left_spaces;
|
|
num_left_spaces = 0;
|
|
}
|
|
|
|
sink->Append(num_left_spaces, ' ');
|
|
sink->Append(sign);
|
|
sink->Append(base_indicator);
|
|
sink->Append(num_zeroes, '0');
|
|
sink->Append(formatted);
|
|
sink->Append(num_right_spaces, ' ');
|
|
return true;
|
|
}
|
|
|
|
template <typename T>
|
|
bool ConvertIntArg(T v, const ConversionSpec conv, FormatSinkImpl *sink) {
|
|
using U = typename MakeUnsigned<T>::type;
|
|
IntDigits as_digits;
|
|
|
|
switch (conv.conversion_char()) {
|
|
case FormatConversionChar::c:
|
|
return ConvertCharImpl(static_cast<unsigned char>(v), conv, sink);
|
|
|
|
case FormatConversionChar::o:
|
|
as_digits.PrintAsOct(static_cast<U>(v));
|
|
break;
|
|
|
|
case FormatConversionChar::x:
|
|
as_digits.PrintAsHexLower(static_cast<U>(v));
|
|
break;
|
|
case FormatConversionChar::X:
|
|
as_digits.PrintAsHexUpper(static_cast<U>(v));
|
|
break;
|
|
|
|
case FormatConversionChar::u:
|
|
as_digits.PrintAsDec(static_cast<U>(v));
|
|
break;
|
|
|
|
case FormatConversionChar::d:
|
|
case FormatConversionChar::i:
|
|
as_digits.PrintAsDec(v);
|
|
break;
|
|
|
|
case FormatConversionChar::a:
|
|
case FormatConversionChar::e:
|
|
case FormatConversionChar::f:
|
|
case FormatConversionChar::g:
|
|
case FormatConversionChar::A:
|
|
case FormatConversionChar::E:
|
|
case FormatConversionChar::F:
|
|
case FormatConversionChar::G:
|
|
return ConvertFloatImpl(static_cast<double>(v), conv, sink);
|
|
|
|
default:
|
|
return false;
|
|
}
|
|
|
|
if (conv.is_basic()) {
|
|
sink->Append(as_digits.with_neg_and_zero());
|
|
return true;
|
|
}
|
|
return ConvertIntImplInnerSlow(as_digits, conv, sink);
|
|
}
|
|
|
|
template <typename T>
|
|
bool ConvertFloatArg(T v, const ConversionSpec conv, FormatSinkImpl *sink) {
|
|
return FormatConversionCharIsFloat(conv.conversion_char()) &&
|
|
ConvertFloatImpl(v, conv, sink);
|
|
}
|
|
|
|
inline bool ConvertStringArg(string_view v, const ConversionSpec conv,
|
|
FormatSinkImpl *sink) {
|
|
if (conv.conversion_char() != FormatConversionCharInternal::s) return false;
|
|
if (conv.is_basic()) {
|
|
sink->Append(v);
|
|
return true;
|
|
}
|
|
return sink->PutPaddedString(v, conv.width(), conv.precision(),
|
|
conv.has_left_flag());
|
|
}
|
|
|
|
} // namespace
|
|
|
|
// ==================== Strings ====================
|
|
StringConvertResult FormatConvertImpl(const std::string &v,
|
|
const ConversionSpec conv,
|
|
FormatSinkImpl *sink) {
|
|
return {ConvertStringArg(v, conv, sink)};
|
|
}
|
|
|
|
StringConvertResult FormatConvertImpl(string_view v, const ConversionSpec conv,
|
|
FormatSinkImpl *sink) {
|
|
return {ConvertStringArg(v, conv, sink)};
|
|
}
|
|
|
|
ArgConvertResult<FormatConversionCharSetUnion(
|
|
FormatConversionCharSetInternal::s, FormatConversionCharSetInternal::p)>
|
|
FormatConvertImpl(const char *v, const ConversionSpec conv,
|
|
FormatSinkImpl *sink) {
|
|
if (conv.conversion_char() == FormatConversionCharInternal::p)
|
|
return {FormatConvertImpl(VoidPtr(v), conv, sink).value};
|
|
size_t len;
|
|
if (v == nullptr) {
|
|
len = 0;
|
|
} else if (conv.precision() < 0) {
|
|
len = std::strlen(v);
|
|
} else {
|
|
// If precision is set, we look for the NUL-terminator on the valid range.
|
|
len = std::find(v, v + conv.precision(), '\0') - v;
|
|
}
|
|
return {ConvertStringArg(string_view(v, len), conv, sink)};
|
|
}
|
|
|
|
// ==================== Raw pointers ====================
|
|
ArgConvertResult<FormatConversionCharSetInternal::p> FormatConvertImpl(
|
|
VoidPtr v, const ConversionSpec conv, FormatSinkImpl *sink) {
|
|
if (conv.conversion_char() != FormatConversionCharInternal::p) return {false};
|
|
if (!v.value) {
|
|
sink->Append("(nil)");
|
|
return {true};
|
|
}
|
|
IntDigits as_digits;
|
|
as_digits.PrintAsHexLower(v.value);
|
|
return {ConvertIntImplInnerSlow(as_digits, conv, sink)};
|
|
}
|
|
|
|
// ==================== Floats ====================
|
|
FloatingConvertResult FormatConvertImpl(float v, const ConversionSpec conv,
|
|
FormatSinkImpl *sink) {
|
|
return {ConvertFloatArg(v, conv, sink)};
|
|
}
|
|
FloatingConvertResult FormatConvertImpl(double v, const ConversionSpec conv,
|
|
FormatSinkImpl *sink) {
|
|
return {ConvertFloatArg(v, conv, sink)};
|
|
}
|
|
FloatingConvertResult FormatConvertImpl(long double v,
|
|
const ConversionSpec conv,
|
|
FormatSinkImpl *sink) {
|
|
return {ConvertFloatArg(v, conv, sink)};
|
|
}
|
|
|
|
// ==================== Chars ====================
|
|
IntegralConvertResult FormatConvertImpl(char v, const ConversionSpec conv,
|
|
FormatSinkImpl *sink) {
|
|
return {ConvertIntArg(v, conv, sink)};
|
|
}
|
|
IntegralConvertResult FormatConvertImpl(signed char v,
|
|
const ConversionSpec conv,
|
|
FormatSinkImpl *sink) {
|
|
return {ConvertIntArg(v, conv, sink)};
|
|
}
|
|
IntegralConvertResult FormatConvertImpl(unsigned char v,
|
|
const ConversionSpec conv,
|
|
FormatSinkImpl *sink) {
|
|
return {ConvertIntArg(v, conv, sink)};
|
|
}
|
|
|
|
// ==================== Ints ====================
|
|
IntegralConvertResult FormatConvertImpl(short v, // NOLINT
|
|
const ConversionSpec conv,
|
|
FormatSinkImpl *sink) {
|
|
return {ConvertIntArg(v, conv, sink)};
|
|
}
|
|
IntegralConvertResult FormatConvertImpl(unsigned short v, // NOLINT
|
|
const ConversionSpec conv,
|
|
FormatSinkImpl *sink) {
|
|
return {ConvertIntArg(v, conv, sink)};
|
|
}
|
|
IntegralConvertResult FormatConvertImpl(int v, const ConversionSpec conv,
|
|
FormatSinkImpl *sink) {
|
|
return {ConvertIntArg(v, conv, sink)};
|
|
}
|
|
IntegralConvertResult FormatConvertImpl(unsigned v, const ConversionSpec conv,
|
|
FormatSinkImpl *sink) {
|
|
return {ConvertIntArg(v, conv, sink)};
|
|
}
|
|
IntegralConvertResult FormatConvertImpl(long v, // NOLINT
|
|
const ConversionSpec conv,
|
|
FormatSinkImpl *sink) {
|
|
return {ConvertIntArg(v, conv, sink)};
|
|
}
|
|
IntegralConvertResult FormatConvertImpl(unsigned long v, // NOLINT
|
|
const ConversionSpec conv,
|
|
FormatSinkImpl *sink) {
|
|
return {ConvertIntArg(v, conv, sink)};
|
|
}
|
|
IntegralConvertResult FormatConvertImpl(long long v, // NOLINT
|
|
const ConversionSpec conv,
|
|
FormatSinkImpl *sink) {
|
|
return {ConvertIntArg(v, conv, sink)};
|
|
}
|
|
IntegralConvertResult FormatConvertImpl(unsigned long long v, // NOLINT
|
|
const ConversionSpec conv,
|
|
FormatSinkImpl *sink) {
|
|
return {ConvertIntArg(v, conv, sink)};
|
|
}
|
|
IntegralConvertResult FormatConvertImpl(absl::int128 v,
|
|
const ConversionSpec conv,
|
|
FormatSinkImpl *sink) {
|
|
return {ConvertIntArg(v, conv, sink)};
|
|
}
|
|
IntegralConvertResult FormatConvertImpl(absl::uint128 v,
|
|
const ConversionSpec conv,
|
|
FormatSinkImpl *sink) {
|
|
return {ConvertIntArg(v, conv, sink)};
|
|
}
|
|
|
|
ABSL_INTERNAL_FORMAT_DISPATCH_OVERLOADS_EXPAND_();
|
|
|
|
|
|
|
|
} // namespace str_format_internal
|
|
|
|
ABSL_NAMESPACE_END
|
|
} // namespace absl
|