Export of internal Abseil changes
-- d447fdcb801036cf08197eece193a5a706661120 by Gennadiy Rozental <rogeeff@google.com>: Eliminate the need for static function holding help message. This decreases the cost of ABSL_FLAG abstraction by 120 bytes under clang. PiperOrigin-RevId: 281107806 -- 0aa6b91189f0e8b2381438c33465673a7ae02487 by Derek Mauro <dmauro@google.com>: Disable the weak symbol CCTZ extension in the time test_util on MinGW, which does not support it. PiperOrigin-RevId: 280719769 -- 67322c41c3e776eb541de90fa4526bdb49422eb6 by Abseil Team <absl-team@google.com>: Tune PeriodicSampler implementation (for internal-use only) PiperOrigin-RevId: 280708943 -- 3a48c346340c7ed03816645cd327e1ff07729aa4 by Abseil Team <absl-team@google.com>: Clean up public headers not to have warnings for "-Wcomma" PiperOrigin-RevId: 280695373 -- 981acd1ef3b13a83a84f04f11c8931f4ed4451c9 by Matthew Brown <matthewbr@google.com>: Release absl::int128. PiperOrigin-RevId: 280690817 -- d30fae9d2ec30b81322d2eb5afe7e13e45b4b422 by Derek Mauro <dmauro@google.com>: Fix -Wundef warnings in random platform detection PiperOrigin-RevId: 280669598 GitOrigin-RevId: d447fdcb801036cf08197eece193a5a706661120 Change-Id: Ie5e10e567c54b7de211833607689f233d4ddf734
This commit is contained in:
Abseil Team
Gennadiy Civil
parent
3df7b52a6a
commit
2103fd9acd
23 changed files with 2800 additions and 136 deletions
|
|
@ -50,10 +50,22 @@ namespace base_internal {
|
|||
|
||||
ABSL_BASE_INTERNAL_FORCEINLINE int CountLeadingZeros64Slow(uint64_t n) {
|
||||
int zeroes = 60;
|
||||
if (n >> 32) zeroes -= 32, n >>= 32;
|
||||
if (n >> 16) zeroes -= 16, n >>= 16;
|
||||
if (n >> 8) zeroes -= 8, n >>= 8;
|
||||
if (n >> 4) zeroes -= 4, n >>= 4;
|
||||
if (n >> 32) {
|
||||
zeroes -= 32;
|
||||
n >>= 32;
|
||||
}
|
||||
if (n >> 16) {
|
||||
zeroes -= 16;
|
||||
n >>= 16;
|
||||
}
|
||||
if (n >> 8) {
|
||||
zeroes -= 8;
|
||||
n >>= 8;
|
||||
}
|
||||
if (n >> 4) {
|
||||
zeroes -= 4;
|
||||
n >>= 4;
|
||||
}
|
||||
return "\4\3\2\2\1\1\1\1\0\0\0\0\0\0\0"[n] + zeroes;
|
||||
}
|
||||
|
||||
|
|
@ -95,9 +107,18 @@ ABSL_BASE_INTERNAL_FORCEINLINE int CountLeadingZeros64(uint64_t n) {
|
|||
|
||||
ABSL_BASE_INTERNAL_FORCEINLINE int CountLeadingZeros32Slow(uint64_t n) {
|
||||
int zeroes = 28;
|
||||
if (n >> 16) zeroes -= 16, n >>= 16;
|
||||
if (n >> 8) zeroes -= 8, n >>= 8;
|
||||
if (n >> 4) zeroes -= 4, n >>= 4;
|
||||
if (n >> 16) {
|
||||
zeroes -= 16;
|
||||
n >>= 16;
|
||||
}
|
||||
if (n >> 8) {
|
||||
zeroes -= 8;
|
||||
n >>= 8;
|
||||
}
|
||||
if (n >> 4) {
|
||||
zeroes -= 4;
|
||||
n >>= 4;
|
||||
}
|
||||
return "\4\3\2\2\1\1\1\1\0\0\0\0\0\0\0"[n] + zeroes;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -36,13 +36,13 @@ bool PeriodicSamplerBase::SubtleConfirmSample() noexcept {
|
|||
|
||||
// Check if this is the first call to Sample()
|
||||
if (ABSL_PREDICT_FALSE(stride_ == 1)) {
|
||||
stride_ = -1 - GetExponentialBiased(current_period);
|
||||
if (stride_ < -1) {
|
||||
stride_ = static_cast<uint64_t>(-1 - GetExponentialBiased(current_period));
|
||||
if (static_cast<int64_t>(stride_) < -1) {
|
||||
++stride_;
|
||||
return false;
|
||||
}
|
||||
}
|
||||
stride_ = -1 - GetExponentialBiased(current_period);
|
||||
stride_ = static_cast<uint64_t>(-1 - GetExponentialBiased(current_period));
|
||||
return true;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -111,33 +111,49 @@ class PeriodicSamplerBase {
|
|||
// Returns the current period of this sampler. Thread-safe.
|
||||
virtual int period() const noexcept = 0;
|
||||
|
||||
int64_t stride_ = 0;
|
||||
// Keep and decrement stride_ as an unsigned integer, but compare the value
|
||||
// to zero casted as a signed int. clang and msvc do not create optimum code
|
||||
// if we use signed for the combined decrement and sign comparison.
|
||||
//
|
||||
// Below 3 alternative options, all compiles generate the best code
|
||||
// using the unsigned increment <---> signed int comparison option.
|
||||
//
|
||||
// Option 1:
|
||||
// int64_t stride_;
|
||||
// if (ABSL_PREDICT_TRUE(++stride_ < 0)) { ... }
|
||||
//
|
||||
// GCC x64 (OK) : https://gcc.godbolt.org/z/R5MzzA
|
||||
// GCC ppc (OK) : https://gcc.godbolt.org/z/z7NZAt
|
||||
// Clang x64 (BAD): https://gcc.godbolt.org/z/t4gPsd
|
||||
// ICC x64 (OK) : https://gcc.godbolt.org/z/rE6s8W
|
||||
// MSVC x64 (OK) : https://gcc.godbolt.org/z/ARMXqS
|
||||
//
|
||||
// Option 2:
|
||||
// int64_t stride_ = 0;
|
||||
// if (ABSL_PREDICT_TRUE(--stride_ >= 0)) { ... }
|
||||
//
|
||||
// GCC x64 (OK) : https://gcc.godbolt.org/z/jSQxYK
|
||||
// GCC ppc (OK) : https://gcc.godbolt.org/z/VJdYaA
|
||||
// Clang x64 (BAD): https://gcc.godbolt.org/z/Xm4NjX
|
||||
// ICC x64 (OK) : https://gcc.godbolt.org/z/4snaFd
|
||||
// MSVC x64 (BAD): https://gcc.godbolt.org/z/BgnEKE
|
||||
//
|
||||
// Option 3:
|
||||
// uint64_t stride_;
|
||||
// if (ABSL_PREDICT_TRUE(static_cast<int64_t>(++stride_) < 0)) { ... }
|
||||
//
|
||||
// GCC x64 (OK) : https://gcc.godbolt.org/z/bFbfPy
|
||||
// GCC ppc (OK) : https://gcc.godbolt.org/z/S9KkUE
|
||||
// Clang x64 (OK) : https://gcc.godbolt.org/z/UYzRb4
|
||||
// ICC x64 (OK) : https://gcc.godbolt.org/z/ptTNfD
|
||||
// MSVC x64 (OK) : https://gcc.godbolt.org/z/76j4-5
|
||||
uint64_t stride_ = 0;
|
||||
ExponentialBiased rng_;
|
||||
};
|
||||
|
||||
inline bool PeriodicSamplerBase::SubtleMaybeSample() noexcept {
|
||||
// We explicitly count up and not down, as the compiler does not generate
|
||||
// ideal code for counting down. See also https://gcc.godbolt.org/z/FTPDSM
|
||||
//
|
||||
// With `if (ABSL_PREDICT_FALSE(++stride_ < 0))`
|
||||
// add QWORD PTR fs:sampler@tpoff+8, 1
|
||||
// jns .L15
|
||||
// ret
|
||||
//
|
||||
// With `if (ABSL_PREDICT_FALSE(--stride_ > 0))`
|
||||
// mov rax, QWORD PTR fs:sampler@tpoff+8
|
||||
// sub rax, 1
|
||||
// mov QWORD PTR fs:sampler@tpoff+8, rax
|
||||
// test rax, rax
|
||||
// jle .L15
|
||||
// ret
|
||||
// add QWORD PTR fs:sampler@tpoff+8, 1
|
||||
// jns .L15
|
||||
// ret
|
||||
//
|
||||
// --stride >= 0 does work, but makes our logic slightly harder as in that
|
||||
// case we have less convenient zero-init and over-run values.
|
||||
if (ABSL_PREDICT_FALSE(++stride_ < 0)) {
|
||||
// See comments on `stride_` for the unsigned increment / signed compare.
|
||||
if (ABSL_PREDICT_TRUE(static_cast<int64_t>(++stride_) < 0)) {
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
|
|
|
|||
|
|
@ -96,8 +96,7 @@ class Flag {
|
|||
constexpr Flag(const char* name, const flags_internal::HelpGenFunc help_gen,
|
||||
const char* filename,
|
||||
const flags_internal::FlagMarshallingOpFn marshalling_op,
|
||||
const flags_internal::InitialValGenFunc initial_value_gen,
|
||||
bool, void*)
|
||||
const flags_internal::InitialValGenFunc initial_value_gen)
|
||||
: name_(name),
|
||||
help_gen_(help_gen),
|
||||
filename_(filename),
|
||||
|
|
@ -115,8 +114,11 @@ class Flag {
|
|||
return impl_;
|
||||
}
|
||||
|
||||
impl_ = new flags_internal::Flag<T>(name_, help_gen_, filename_,
|
||||
marshalling_op_, initial_value_gen_);
|
||||
impl_ = new flags_internal::Flag<T>(
|
||||
name_,
|
||||
{flags_internal::FlagHelpSrc(help_gen_),
|
||||
flags_internal::FlagHelpSrcKind::kGenFunc},
|
||||
filename_, marshalling_op_, initial_value_gen_);
|
||||
inited_.store(true, std::memory_order_release);
|
||||
}
|
||||
|
||||
|
|
@ -307,9 +309,19 @@ void SetFlag(absl::Flag<T>* flag, const V& v) {
|
|||
#define ABSL_FLAG_IMPL_FLAGHELP(txt) txt
|
||||
#endif
|
||||
|
||||
#define ABSL_FLAG_IMPL_DECLARE_HELP_WRAPPER(name, txt) \
|
||||
static std::string AbslFlagsWrapHelp##name() { \
|
||||
return ABSL_FLAG_IMPL_FLAGHELP(txt); \
|
||||
// AbslFlagHelpGenFor##name is used to encapsulate both immediate (method Const)
|
||||
// and lazy (method NonConst) evaluation of help message expression. We choose
|
||||
// between the two via the call to HelpArg in absl::Flag instantiation below.
|
||||
// If help message expression is constexpr evaluable compiler will optimize
|
||||
// away this whole struct.
|
||||
#define ABSL_FLAG_IMPL_DECLARE_HELP_WRAPPER(name, txt) \
|
||||
struct AbslFlagHelpGenFor##name { \
|
||||
template <typename T = void> \
|
||||
static constexpr const char* Const() { \
|
||||
return absl::flags_internal::HelpConstexprWrap( \
|
||||
ABSL_FLAG_IMPL_FLAGHELP(txt)); \
|
||||
} \
|
||||
static std::string NonConst() { return ABSL_FLAG_IMPL_FLAGHELP(txt); } \
|
||||
}
|
||||
|
||||
#define ABSL_FLAG_IMPL_DECLARE_DEF_VAL_WRAPPER(name, Type, default_value) \
|
||||
|
|
@ -326,29 +338,28 @@ void SetFlag(absl::Flag<T>* flag, const V& v) {
|
|||
#define ABSL_FLAG_IMPL(Type, name, default_value, help) \
|
||||
namespace absl /* block flags in namespaces */ {} \
|
||||
ABSL_FLAG_IMPL_DECLARE_DEF_VAL_WRAPPER(name, Type, default_value) \
|
||||
ABSL_FLAG_IMPL_DECLARE_HELP_WRAPPER(name, help) \
|
||||
ABSL_FLAG_IMPL_DECLARE_HELP_WRAPPER(name, help); \
|
||||
ABSL_CONST_INIT absl::Flag<Type> FLAGS_##name{ \
|
||||
ABSL_FLAG_IMPL_FLAGNAME(#name), &AbslFlagsWrapHelp##name, \
|
||||
ABSL_FLAG_IMPL_FLAGNAME(#name), \
|
||||
absl::flags_internal::HelpArg<AbslFlagHelpGenFor##name>(0), \
|
||||
ABSL_FLAG_IMPL_FILENAME(), \
|
||||
&absl::flags_internal::FlagMarshallingOps<Type>, \
|
||||
&AbslFlagsInitFlag##name}; \
|
||||
extern bool FLAGS_no##name; \
|
||||
bool FLAGS_no##name = ABSL_FLAG_IMPL_REGISTRAR(Type, FLAGS_##name)
|
||||
#else
|
||||
// MSVC version uses aggregate initialization.
|
||||
#define ABSL_FLAG_IMPL(Type, name, default_value, help) \
|
||||
namespace absl /* block flags in namespaces */ {} \
|
||||
ABSL_FLAG_IMPL_DECLARE_DEF_VAL_WRAPPER(name, Type, default_value) \
|
||||
ABSL_FLAG_IMPL_DECLARE_HELP_WRAPPER(name, help) \
|
||||
ABSL_CONST_INIT absl::Flag<Type> FLAGS_##name{ \
|
||||
ABSL_FLAG_IMPL_FLAGNAME(#name), \
|
||||
&AbslFlagsWrapHelp##name, \
|
||||
ABSL_FLAG_IMPL_FILENAME(), \
|
||||
&absl::flags_internal::FlagMarshallingOps<Type>, \
|
||||
&AbslFlagsInitFlag##name, \
|
||||
false, \
|
||||
nullptr}; \
|
||||
extern bool FLAGS_no##name; \
|
||||
// MSVC version uses aggregate initialization. We also do not try to
|
||||
// optimize away help wrapper.
|
||||
#define ABSL_FLAG_IMPL(Type, name, default_value, help) \
|
||||
namespace absl /* block flags in namespaces */ {} \
|
||||
ABSL_FLAG_IMPL_DECLARE_DEF_VAL_WRAPPER(name, Type, default_value) \
|
||||
ABSL_FLAG_IMPL_DECLARE_HELP_WRAPPER(name, help); \
|
||||
ABSL_CONST_INIT absl::Flag<Type> FLAGS_##name{ \
|
||||
ABSL_FLAG_IMPL_FLAGNAME(#name), &AbslFlagHelpGenFor##name::NonConst, \
|
||||
ABSL_FLAG_IMPL_FILENAME(), \
|
||||
&absl::flags_internal::FlagMarshallingOps<Type>, \
|
||||
&AbslFlagsInitFlag##name}; \
|
||||
extern bool FLAGS_no##name; \
|
||||
bool FLAGS_no##name = ABSL_FLAG_IMPL_REGISTRAR(Type, FLAGS_##name)
|
||||
#endif
|
||||
|
||||
|
|
|
|||
|
|
@ -32,7 +32,7 @@ namespace {
|
|||
|
||||
namespace flags = absl::flags_internal;
|
||||
|
||||
std::string TestHelpMsg() { return "help"; }
|
||||
std::string TestHelpMsg() { return "dynamic help"; }
|
||||
template <typename T>
|
||||
void* TestMakeDflt() {
|
||||
return new T{};
|
||||
|
|
@ -41,19 +41,22 @@ void TestCallback() {}
|
|||
|
||||
template <typename T>
|
||||
bool TestConstructionFor() {
|
||||
constexpr flags::Flag<T> f1("f1", &TestHelpMsg, "file",
|
||||
constexpr flags::HelpInitArg help_arg{flags::FlagHelpSrc("literal help"),
|
||||
flags::FlagHelpSrcKind::kLiteral};
|
||||
constexpr flags::Flag<T> f1("f1", help_arg, "file",
|
||||
&flags::FlagMarshallingOps<T>, &TestMakeDflt<T>);
|
||||
EXPECT_EQ(f1.Name(), "f1");
|
||||
EXPECT_EQ(f1.Help(), "help");
|
||||
EXPECT_EQ(f1.Help(), "literal help");
|
||||
EXPECT_EQ(f1.Filename(), "file");
|
||||
|
||||
ABSL_CONST_INIT static flags::Flag<T> f2("f2", &TestHelpMsg, "file",
|
||||
&flags::FlagMarshallingOps<T>,
|
||||
&TestMakeDflt<T>);
|
||||
ABSL_CONST_INIT static flags::Flag<T> f2(
|
||||
"f2",
|
||||
{flags::FlagHelpSrc(&TestHelpMsg), flags::FlagHelpSrcKind::kGenFunc},
|
||||
"file", &flags::FlagMarshallingOps<T>, &TestMakeDflt<T>);
|
||||
flags::FlagRegistrar<T, false>(&f2).OnUpdate(TestCallback);
|
||||
|
||||
EXPECT_EQ(f2.Name(), "f2");
|
||||
EXPECT_EQ(f2.Help(), "help");
|
||||
EXPECT_EQ(f2.Help(), "dynamic help");
|
||||
EXPECT_EQ(f2.Filename(), "file");
|
||||
|
||||
return true;
|
||||
|
|
|
|||
|
|
@ -56,12 +56,5 @@ std::string CommandLineFlag::Filename() const {
|
|||
return flags_internal::GetUsageConfig().normalize_filename(filename_);
|
||||
}
|
||||
|
||||
std::string HelpText::GetHelpText() const {
|
||||
if (help_function_) return help_function_();
|
||||
if (help_message_) return help_message_;
|
||||
|
||||
return {};
|
||||
}
|
||||
|
||||
} // namespace flags_internal
|
||||
} // namespace absl
|
||||
|
|
|
|||
|
|
@ -60,14 +60,6 @@ enum ValueSource {
|
|||
kProgrammaticChange,
|
||||
};
|
||||
|
||||
// Signature for the help generation function used as an argument for the
|
||||
// absl::Flag constructor.
|
||||
using HelpGenFunc = std::string (*)();
|
||||
|
||||
// Signature for the function generating the initial flag value based (usually
|
||||
// based on default value supplied in flag's definition)
|
||||
using InitialValGenFunc = void* (*)();
|
||||
|
||||
extern const char kStrippedFlagHelp[];
|
||||
|
||||
// The per-type function
|
||||
|
|
@ -149,34 +141,6 @@ inline size_t Sizeof(FlagOpFn op) {
|
|||
op(flags_internal::kSizeof, nullptr, nullptr)));
|
||||
}
|
||||
|
||||
// Holds either a pointer to help text or a function which produces it. This is
|
||||
// needed for supporting both static initialization of Flags while supporting
|
||||
// the legacy registration framework. We can't use absl::variant<const char*,
|
||||
// const char*(*)()> since anybody passing 0 or nullptr in to a CommandLineFlag
|
||||
// would find an ambiguity.
|
||||
class HelpText {
|
||||
public:
|
||||
static constexpr HelpText FromFunctionPointer(const HelpGenFunc fn) {
|
||||
return HelpText(fn, nullptr);
|
||||
}
|
||||
static constexpr HelpText FromStaticCString(const char* msg) {
|
||||
return HelpText(nullptr, msg);
|
||||
}
|
||||
|
||||
std::string GetHelpText() const;
|
||||
|
||||
HelpText() = delete;
|
||||
HelpText(const HelpText&) = default;
|
||||
HelpText(HelpText&&) = default;
|
||||
|
||||
private:
|
||||
explicit constexpr HelpText(const HelpGenFunc fn, const char* msg)
|
||||
: help_function_(fn), help_message_(msg) {}
|
||||
|
||||
HelpGenFunc help_function_;
|
||||
const char* help_message_;
|
||||
};
|
||||
|
||||
// Handle to FlagState objects. Specific flag state objects will restore state
|
||||
// of a flag produced this flag state from method CommandLineFlag::SaveState().
|
||||
class FlagStateInterface {
|
||||
|
|
@ -190,9 +154,8 @@ class FlagStateInterface {
|
|||
// Holds all information for a flag.
|
||||
class CommandLineFlag {
|
||||
public:
|
||||
constexpr CommandLineFlag(const char* name, HelpText help_text,
|
||||
const char* filename)
|
||||
: name_(name), help_(help_text), filename_(filename) {}
|
||||
constexpr CommandLineFlag(const char* name, const char* filename)
|
||||
: name_(name), filename_(filename) {}
|
||||
|
||||
// Virtual destructor
|
||||
virtual void Destroy() const = 0;
|
||||
|
|
@ -203,7 +166,6 @@ class CommandLineFlag {
|
|||
|
||||
// Non-polymorphic access methods.
|
||||
absl::string_view Name() const { return name_; }
|
||||
std::string Help() const { return help_.GetHelpText(); }
|
||||
absl::string_view Typename() const;
|
||||
std::string Filename() const;
|
||||
|
||||
|
|
@ -250,6 +212,8 @@ class CommandLineFlag {
|
|||
|
||||
// Polymorphic access methods
|
||||
|
||||
// Returns help message associated with this flag
|
||||
virtual std::string Help() const = 0;
|
||||
// Returns true iff this object corresponds to retired flag
|
||||
virtual bool IsRetired() const { return false; }
|
||||
// Returns true iff this is a handle to an Abseil Flag.
|
||||
|
|
@ -285,12 +249,11 @@ class CommandLineFlag {
|
|||
// flag's value type.
|
||||
virtual void CheckDefaultValueParsingRoundtrip() const = 0;
|
||||
|
||||
// Constant configuration for a particular flag.
|
||||
protected:
|
||||
~CommandLineFlag() = default;
|
||||
|
||||
// Constant configuration for a particular flag.
|
||||
const char* const name_; // Flags name passed to ABSL_FLAG as second arg.
|
||||
const HelpText help_; // The function generating help message.
|
||||
const char* const filename_; // The file name where ABSL_FLAG resides.
|
||||
|
||||
private:
|
||||
|
|
|
|||
|
|
@ -85,6 +85,11 @@ void FlagImpl::Destroy() const {
|
|||
delete locks_;
|
||||
}
|
||||
|
||||
std::string FlagImpl::Help() const {
|
||||
return help_source_kind_ == FlagHelpSrcKind::kLiteral ? help_.literal
|
||||
: help_.gen_func();
|
||||
}
|
||||
|
||||
bool FlagImpl::IsModified() const {
|
||||
absl::MutexLock l(DataGuard());
|
||||
return modified_;
|
||||
|
|
|
|||
|
|
@ -61,6 +61,68 @@ class FlagState : public flags_internal::FlagStateInterface {
|
|||
int64_t counter_;
|
||||
};
|
||||
|
||||
// This is help argument for absl::Flag encapsulating the string literal pointer
|
||||
// or pointer to function generating it as well as enum descriminating two
|
||||
// cases.
|
||||
using HelpGenFunc = std::string (*)();
|
||||
|
||||
union FlagHelpSrc {
|
||||
constexpr explicit FlagHelpSrc(const char* help_msg) : literal(help_msg) {}
|
||||
constexpr explicit FlagHelpSrc(HelpGenFunc help_gen) : gen_func(help_gen) {}
|
||||
|
||||
const char* literal;
|
||||
HelpGenFunc gen_func;
|
||||
};
|
||||
|
||||
enum class FlagHelpSrcKind : int8_t { kLiteral, kGenFunc };
|
||||
|
||||
struct HelpInitArg {
|
||||
FlagHelpSrc source;
|
||||
FlagHelpSrcKind kind;
|
||||
};
|
||||
|
||||
// HelpConstexprWrap is used by struct AbslFlagHelpGenFor##name generated by
|
||||
// ABSL_FLAG macro. It is only used to silence the compiler in the case where
|
||||
// help message expression is not constexpr and does not have type const char*.
|
||||
// If help message expression is indeed constexpr const char* HelpConstexprWrap
|
||||
// is just a trivial identity function.
|
||||
template <typename T>
|
||||
const char* HelpConstexprWrap(const T&) {
|
||||
return nullptr;
|
||||
}
|
||||
constexpr const char* HelpConstexprWrap(const char* p) { return p; }
|
||||
constexpr const char* HelpConstexprWrap(char* p) { return p; }
|
||||
|
||||
// These two HelpArg overloads allows us to select at compile time one of two
|
||||
// way to pass Help argument to absl::Flag. We'll be passing
|
||||
// AbslFlagHelpGenFor##name as T and integer 0 as a single argument to prefer
|
||||
// first overload if possible. If T::Const is evaluatable on constexpr
|
||||
// context (see non template int parameter below) we'll choose first overload.
|
||||
// In this case the help message expression is immediately evaluated and is used
|
||||
// to construct the absl::Flag. No additionl code is generated by ABSL_FLAG.
|
||||
// Otherwise SFINAE kicks in and first overload is dropped from the
|
||||
// consideration, in which case the second overload will be used. The second
|
||||
// overload does not attempt to evaluate the help message expression
|
||||
// immediately and instead delays the evaluation by returing the function
|
||||
// pointer (&T::NonConst) genering the help message when necessary. This is
|
||||
// evaluatable in constexpr context, but the cost is an extra function being
|
||||
// generated in the ABSL_FLAG code.
|
||||
template <typename T, int = (T::Const(), 1)>
|
||||
constexpr flags_internal::HelpInitArg HelpArg(int) {
|
||||
return {flags_internal::FlagHelpSrc(T::Const()),
|
||||
flags_internal::FlagHelpSrcKind::kLiteral};
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
constexpr flags_internal::HelpInitArg HelpArg(char) {
|
||||
return {flags_internal::FlagHelpSrc(&T::NonConst),
|
||||
flags_internal::FlagHelpSrcKind::kGenFunc};
|
||||
}
|
||||
|
||||
// Signature for the function generating the initial flag value based (usually
|
||||
// based on default value supplied in flag's definition)
|
||||
using InitialValGenFunc = void* (*)();
|
||||
|
||||
// Signature for the mutation callback used by watched Flags
|
||||
// The callback is noexcept.
|
||||
// TODO(rogeeff): add noexcept after C++17 support is added.
|
||||
|
|
@ -74,15 +136,19 @@ class FlagImpl {
|
|||
public:
|
||||
constexpr FlagImpl(const flags_internal::FlagOpFn op,
|
||||
const flags_internal::FlagMarshallingOpFn marshalling_op,
|
||||
const flags_internal::InitialValGenFunc initial_value_gen)
|
||||
const flags_internal::InitialValGenFunc initial_value_gen,
|
||||
const HelpInitArg help)
|
||||
: op_(op),
|
||||
marshalling_op_(marshalling_op),
|
||||
initial_value_gen_(initial_value_gen) {}
|
||||
initial_value_gen_(initial_value_gen),
|
||||
help_(help.source),
|
||||
help_source_kind_(help.kind) {}
|
||||
|
||||
// Forces destruction of the Flag's data.
|
||||
void Destroy() const;
|
||||
|
||||
// Constant access methods
|
||||
std::string Help() const;
|
||||
bool IsModified() const ABSL_LOCKS_EXCLUDED(locks_->primary_mu);
|
||||
bool IsSpecifiedOnCommandLine() const ABSL_LOCKS_EXCLUDED(locks_->primary_mu);
|
||||
std::string DefaultValue() const ABSL_LOCKS_EXCLUDED(locks_->primary_mu);
|
||||
|
|
@ -149,9 +215,12 @@ class FlagImpl {
|
|||
absl::Mutex* DataGuard() const ABSL_LOCK_RETURNED(locks_->primary_mu);
|
||||
|
||||
// Immutable Flag's data.
|
||||
const FlagOpFn op_; // Type-specific handler
|
||||
const FlagMarshallingOpFn marshalling_op_; // Marshalling ops handler
|
||||
const InitialValGenFunc initial_value_gen_; // Makes flag's initial value
|
||||
const FlagOpFn op_; // Type-specific handler.
|
||||
const FlagMarshallingOpFn marshalling_op_; // Marshalling ops handler.
|
||||
const InitialValGenFunc initial_value_gen_; // Makes flag's initial value.
|
||||
const FlagHelpSrc help_; // Help message literal or function to generate it.
|
||||
// Indicates if help message was supplied as literal or generator func.
|
||||
const FlagHelpSrcKind help_source_kind_;
|
||||
|
||||
// Mutable Flag's data. (guarded by locks_->primary_mu).
|
||||
// Indicates that locks_, cur_ and def_ fields have been lazily initialized.
|
||||
|
|
@ -191,14 +260,13 @@ class FlagImpl {
|
|||
template <typename T>
|
||||
class Flag final : public flags_internal::CommandLineFlag {
|
||||
public:
|
||||
constexpr Flag(const char* name, const flags_internal::HelpGenFunc help_gen,
|
||||
constexpr Flag(const char* name, const flags_internal::HelpInitArg help,
|
||||
const char* filename,
|
||||
const flags_internal::FlagMarshallingOpFn marshalling_op,
|
||||
const flags_internal::InitialValGenFunc initial_value_gen)
|
||||
: flags_internal::CommandLineFlag(
|
||||
name, flags_internal::HelpText::FromFunctionPointer(help_gen),
|
||||
filename),
|
||||
impl_(&flags_internal::FlagOps<T>, marshalling_op, initial_value_gen) {}
|
||||
: flags_internal::CommandLineFlag(name, filename),
|
||||
impl_(&flags_internal::FlagOps<T>, marshalling_op, initial_value_gen,
|
||||
help) {}
|
||||
|
||||
T Get() const {
|
||||
// See implementation notes in CommandLineFlag::Get().
|
||||
|
|
@ -222,6 +290,7 @@ class Flag final : public flags_internal::CommandLineFlag {
|
|||
}
|
||||
|
||||
// CommandLineFlag interface
|
||||
std::string Help() const override { return impl_.Help(); }
|
||||
bool IsModified() const override { return impl_.IsModified(); }
|
||||
bool IsSpecifiedOnCommandLine() const override {
|
||||
return impl_.IsSpecifiedOnCommandLine();
|
||||
|
|
|
|||
|
|
@ -276,9 +276,8 @@ namespace {
|
|||
class RetiredFlagObj final : public flags_internal::CommandLineFlag {
|
||||
public:
|
||||
constexpr RetiredFlagObj(const char* name, FlagOpFn ops)
|
||||
: flags_internal::CommandLineFlag(
|
||||
name, flags_internal::HelpText::FromStaticCString(nullptr),
|
||||
/*filename=*/"RETIRED"),
|
||||
: flags_internal::CommandLineFlag(name,
|
||||
/*filename=*/"RETIRED"),
|
||||
op_(ops) {}
|
||||
|
||||
private:
|
||||
|
|
@ -288,6 +287,7 @@ class RetiredFlagObj final : public flags_internal::CommandLineFlag {
|
|||
}
|
||||
|
||||
flags_internal::FlagOpFn TypeId() const override { return op_; }
|
||||
std::string Help() const override { return ""; }
|
||||
bool IsRetired() const override { return true; }
|
||||
bool IsModified() const override { return false; }
|
||||
bool IsSpecifiedOnCommandLine() const override { return false; }
|
||||
|
|
|
|||
|
|
@ -244,6 +244,111 @@ std::ostream& operator<<(std::ostream& os, uint128 v) {
|
|||
return os << rep;
|
||||
}
|
||||
|
||||
namespace {
|
||||
|
||||
uint128 UnsignedAbsoluteValue(int128 v) {
|
||||
// Cast to uint128 before possibly negating because -Int128Min() is undefined.
|
||||
return Int128High64(v) < 0 ? -uint128(v) : uint128(v);
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
#if !defined(ABSL_HAVE_INTRINSIC_INT128)
|
||||
namespace {
|
||||
|
||||
template <typename T>
|
||||
int128 MakeInt128FromFloat(T v) {
|
||||
// Conversion when v is NaN or cannot fit into int128 would be undefined
|
||||
// behavior if using an intrinsic 128-bit integer.
|
||||
assert(std::isfinite(v) && (std::numeric_limits<T>::max_exponent <= 127 ||
|
||||
(v >= -std::ldexp(static_cast<T>(1), 127) &&
|
||||
v < std::ldexp(static_cast<T>(1), 127))));
|
||||
|
||||
// We must convert the absolute value and then negate as needed, because
|
||||
// floating point types are typically sign-magnitude. Otherwise, the
|
||||
// difference between the high and low 64 bits when interpreted as two's
|
||||
// complement overwhelms the precision of the mantissa.
|
||||
uint128 result = v < 0 ? -MakeUint128FromFloat(-v) : MakeUint128FromFloat(v);
|
||||
return MakeInt128(int128_internal::BitCastToSigned(Uint128High64(result)),
|
||||
Uint128Low64(result));
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
int128::int128(float v) : int128(MakeInt128FromFloat(v)) {}
|
||||
int128::int128(double v) : int128(MakeInt128FromFloat(v)) {}
|
||||
int128::int128(long double v) : int128(MakeInt128FromFloat(v)) {}
|
||||
|
||||
int128 operator/(int128 lhs, int128 rhs) {
|
||||
assert(lhs != Int128Min() || rhs != -1); // UB on two's complement.
|
||||
|
||||
uint128 quotient = 0;
|
||||
uint128 remainder = 0;
|
||||
DivModImpl(UnsignedAbsoluteValue(lhs), UnsignedAbsoluteValue(rhs),
|
||||
"ient, &remainder);
|
||||
if ((Int128High64(lhs) < 0) != (Int128High64(rhs) < 0)) quotient = -quotient;
|
||||
return MakeInt128(int128_internal::BitCastToSigned(Uint128High64(quotient)),
|
||||
Uint128Low64(quotient));
|
||||
}
|
||||
|
||||
int128 operator%(int128 lhs, int128 rhs) {
|
||||
assert(lhs != Int128Min() || rhs != -1); // UB on two's complement.
|
||||
|
||||
uint128 quotient = 0;
|
||||
uint128 remainder = 0;
|
||||
DivModImpl(UnsignedAbsoluteValue(lhs), UnsignedAbsoluteValue(rhs),
|
||||
"ient, &remainder);
|
||||
if (Int128High64(lhs) < 0) remainder = -remainder;
|
||||
return MakeInt128(int128_internal::BitCastToSigned(Uint128High64(remainder)),
|
||||
Uint128Low64(remainder));
|
||||
}
|
||||
#endif // ABSL_HAVE_INTRINSIC_INT128
|
||||
|
||||
std::ostream& operator<<(std::ostream& os, int128 v) {
|
||||
std::ios_base::fmtflags flags = os.flags();
|
||||
std::string rep;
|
||||
|
||||
// Add the sign if needed.
|
||||
bool print_as_decimal =
|
||||
(flags & std::ios::basefield) == std::ios::dec ||
|
||||
(flags & std::ios::basefield) == std::ios_base::fmtflags();
|
||||
if (print_as_decimal) {
|
||||
if (Int128High64(v) < 0) {
|
||||
rep = "-";
|
||||
} else if (flags & std::ios::showpos) {
|
||||
rep = "+";
|
||||
}
|
||||
}
|
||||
|
||||
rep.append(Uint128ToFormattedString(
|
||||
print_as_decimal ? UnsignedAbsoluteValue(v) : uint128(v), os.flags()));
|
||||
|
||||
// Add the requisite padding.
|
||||
std::streamsize width = os.width(0);
|
||||
if (static_cast<size_t>(width) > rep.size()) {
|
||||
switch (flags & std::ios::adjustfield) {
|
||||
case std::ios::left:
|
||||
rep.append(width - rep.size(), os.fill());
|
||||
break;
|
||||
case std::ios::internal:
|
||||
if (print_as_decimal && (rep[0] == '+' || rep[0] == '-')) {
|
||||
rep.insert(1, width - rep.size(), os.fill());
|
||||
} else if ((flags & std::ios::basefield) == std::ios::hex &&
|
||||
(flags & std::ios::showbase) && v != 0) {
|
||||
rep.insert(2, width - rep.size(), os.fill());
|
||||
} else {
|
||||
rep.insert(0, width - rep.size(), os.fill());
|
||||
}
|
||||
break;
|
||||
default: // std::ios::right
|
||||
rep.insert(0, width - rep.size(), os.fill());
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
return os << rep;
|
||||
}
|
||||
|
||||
} // namespace absl
|
||||
|
||||
namespace std {
|
||||
|
|
@ -270,4 +375,28 @@ constexpr int numeric_limits<absl::uint128>::max_exponent;
|
|||
constexpr int numeric_limits<absl::uint128>::max_exponent10;
|
||||
constexpr bool numeric_limits<absl::uint128>::traps;
|
||||
constexpr bool numeric_limits<absl::uint128>::tinyness_before;
|
||||
|
||||
constexpr bool numeric_limits<absl::int128>::is_specialized;
|
||||
constexpr bool numeric_limits<absl::int128>::is_signed;
|
||||
constexpr bool numeric_limits<absl::int128>::is_integer;
|
||||
constexpr bool numeric_limits<absl::int128>::is_exact;
|
||||
constexpr bool numeric_limits<absl::int128>::has_infinity;
|
||||
constexpr bool numeric_limits<absl::int128>::has_quiet_NaN;
|
||||
constexpr bool numeric_limits<absl::int128>::has_signaling_NaN;
|
||||
constexpr float_denorm_style numeric_limits<absl::int128>::has_denorm;
|
||||
constexpr bool numeric_limits<absl::int128>::has_denorm_loss;
|
||||
constexpr float_round_style numeric_limits<absl::int128>::round_style;
|
||||
constexpr bool numeric_limits<absl::int128>::is_iec559;
|
||||
constexpr bool numeric_limits<absl::int128>::is_bounded;
|
||||
constexpr bool numeric_limits<absl::int128>::is_modulo;
|
||||
constexpr int numeric_limits<absl::int128>::digits;
|
||||
constexpr int numeric_limits<absl::int128>::digits10;
|
||||
constexpr int numeric_limits<absl::int128>::max_digits10;
|
||||
constexpr int numeric_limits<absl::int128>::radix;
|
||||
constexpr int numeric_limits<absl::int128>::min_exponent;
|
||||
constexpr int numeric_limits<absl::int128>::min_exponent10;
|
||||
constexpr int numeric_limits<absl::int128>::max_exponent;
|
||||
constexpr int numeric_limits<absl::int128>::max_exponent10;
|
||||
constexpr bool numeric_limits<absl::int128>::traps;
|
||||
constexpr bool numeric_limits<absl::int128>::tinyness_before;
|
||||
} // namespace std
|
||||
|
|
|
|||
|
|
@ -17,10 +17,7 @@
|
|||
// File: int128.h
|
||||
// -----------------------------------------------------------------------------
|
||||
//
|
||||
// This header file defines 128-bit integer types.
|
||||
//
|
||||
// Currently, this file defines `uint128`, an unsigned 128-bit integer;
|
||||
// a signed 128-bit integer is forthcoming.
|
||||
// This header file defines 128-bit integer types, `uint128` and `int128`.
|
||||
|
||||
#ifndef ABSL_NUMERIC_INT128_H_
|
||||
#define ABSL_NUMERIC_INT128_H_
|
||||
|
|
@ -53,6 +50,8 @@
|
|||
|
||||
namespace absl {
|
||||
|
||||
class int128;
|
||||
|
||||
// uint128
|
||||
//
|
||||
// An unsigned 128-bit integer type. The API is meant to mimic an intrinsic type
|
||||
|
|
@ -116,6 +115,7 @@ class
|
|||
constexpr uint128(__int128 v); // NOLINT(runtime/explicit)
|
||||
constexpr uint128(unsigned __int128 v); // NOLINT(runtime/explicit)
|
||||
#endif // ABSL_HAVE_INTRINSIC_INT128
|
||||
constexpr uint128(int128 v); // NOLINT(runtime/explicit)
|
||||
explicit uint128(float v);
|
||||
explicit uint128(double v);
|
||||
explicit uint128(long double v);
|
||||
|
|
@ -131,6 +131,7 @@ class
|
|||
uint128& operator=(__int128 v);
|
||||
uint128& operator=(unsigned __int128 v);
|
||||
#endif // ABSL_HAVE_INTRINSIC_INT128
|
||||
uint128& operator=(int128 v);
|
||||
|
||||
// Conversion operators to other arithmetic types
|
||||
constexpr explicit operator bool() const;
|
||||
|
|
@ -291,7 +292,238 @@ class numeric_limits<absl::uint128> {
|
|||
};
|
||||
} // namespace std
|
||||
|
||||
// TODO(absl-team): Implement signed 128-bit type
|
||||
namespace absl {
|
||||
|
||||
// int128
|
||||
//
|
||||
// A signed 128-bit integer type. The API is meant to mimic an intrinsic
|
||||
// integral type as closely as is practical, including exhibiting undefined
|
||||
// behavior in analogous cases (e.g. division by zero).
|
||||
//
|
||||
// An `int128` supports the following:
|
||||
//
|
||||
// * Implicit construction from integral types
|
||||
// * Explicit conversion to integral types
|
||||
//
|
||||
// However, an `int128` differs from intrinsic integral types in the following
|
||||
// ways:
|
||||
//
|
||||
// * It is not implicitly convertible to other integral types.
|
||||
// * Requires explicit construction from and conversion to floating point
|
||||
// types.
|
||||
|
||||
// Additionally, if your compiler supports `__int128`, `int128` is
|
||||
// interoperable with that type. (Abseil checks for this compatibility through
|
||||
// the `ABSL_HAVE_INTRINSIC_INT128` macro.)
|
||||
//
|
||||
// The design goal for `int128` is that it will be compatible with a future
|
||||
// `int128_t`, if that type becomes a part of the standard.
|
||||
//
|
||||
// Example:
|
||||
//
|
||||
// float y = absl::int128(17); // Error. int128 cannot be implicitly
|
||||
// // converted to float.
|
||||
//
|
||||
// absl::int128 v;
|
||||
// int64_t i = v; // Error
|
||||
// int64_t i = static_cast<int64_t>(v); // OK
|
||||
//
|
||||
class int128 {
|
||||
public:
|
||||
int128() = default;
|
||||
|
||||
// Constructors from arithmetic types
|
||||
constexpr int128(int v); // NOLINT(runtime/explicit)
|
||||
constexpr int128(unsigned int v); // NOLINT(runtime/explicit)
|
||||
constexpr int128(long v); // NOLINT(runtime/int)
|
||||
constexpr int128(unsigned long v); // NOLINT(runtime/int)
|
||||
constexpr int128(long long v); // NOLINT(runtime/int)
|
||||
constexpr int128(unsigned long long v); // NOLINT(runtime/int)
|
||||
#ifdef ABSL_HAVE_INTRINSIC_INT128
|
||||
constexpr int128(__int128 v); // NOLINT(runtime/explicit)
|
||||
constexpr explicit int128(unsigned __int128 v);
|
||||
#endif // ABSL_HAVE_INTRINSIC_INT128
|
||||
constexpr explicit int128(uint128 v);
|
||||
explicit int128(float v);
|
||||
explicit int128(double v);
|
||||
explicit int128(long double v);
|
||||
|
||||
// Assignment operators from arithmetic types
|
||||
int128& operator=(int v);
|
||||
int128& operator=(unsigned int v);
|
||||
int128& operator=(long v); // NOLINT(runtime/int)
|
||||
int128& operator=(unsigned long v); // NOLINT(runtime/int)
|
||||
int128& operator=(long long v); // NOLINT(runtime/int)
|
||||
int128& operator=(unsigned long long v); // NOLINT(runtime/int)
|
||||
#ifdef ABSL_HAVE_INTRINSIC_INT128
|
||||
int128& operator=(__int128 v);
|
||||
#endif // ABSL_HAVE_INTRINSIC_INT128
|
||||
|
||||
// Conversion operators to other arithmetic types
|
||||
constexpr explicit operator bool() const;
|
||||
constexpr explicit operator char() const;
|
||||
constexpr explicit operator signed char() const;
|
||||
constexpr explicit operator unsigned char() const;
|
||||
constexpr explicit operator char16_t() const;
|
||||
constexpr explicit operator char32_t() const;
|
||||
constexpr explicit operator ABSL_INTERNAL_WCHAR_T() const;
|
||||
constexpr explicit operator short() const; // NOLINT(runtime/int)
|
||||
// NOLINTNEXTLINE(runtime/int)
|
||||
constexpr explicit operator unsigned short() const;
|
||||
constexpr explicit operator int() const;
|
||||
constexpr explicit operator unsigned int() const;
|
||||
constexpr explicit operator long() const; // NOLINT(runtime/int)
|
||||
// NOLINTNEXTLINE(runtime/int)
|
||||
constexpr explicit operator unsigned long() const;
|
||||
// NOLINTNEXTLINE(runtime/int)
|
||||
constexpr explicit operator long long() const;
|
||||
// NOLINTNEXTLINE(runtime/int)
|
||||
constexpr explicit operator unsigned long long() const;
|
||||
#ifdef ABSL_HAVE_INTRINSIC_INT128
|
||||
constexpr explicit operator __int128() const;
|
||||
constexpr explicit operator unsigned __int128() const;
|
||||
#endif // ABSL_HAVE_INTRINSIC_INT128
|
||||
explicit operator float() const;
|
||||
explicit operator double() const;
|
||||
explicit operator long double() const;
|
||||
|
||||
// Trivial copy constructor, assignment operator and destructor.
|
||||
|
||||
// Arithmetic operators
|
||||
int128& operator+=(int128 other);
|
||||
int128& operator-=(int128 other);
|
||||
int128& operator*=(int128 other);
|
||||
int128& operator/=(int128 other);
|
||||
int128& operator%=(int128 other);
|
||||
int128 operator++(int); // postfix increment: i++
|
||||
int128 operator--(int); // postfix decrement: i--
|
||||
int128& operator++(); // prefix increment: ++i
|
||||
int128& operator--(); // prefix decrement: --i
|
||||
int128& operator&=(int128 other);
|
||||
int128& operator|=(int128 other);
|
||||
int128& operator^=(int128 other);
|
||||
int128& operator<<=(int amount);
|
||||
int128& operator>>=(int amount);
|
||||
|
||||
// Int128Low64()
|
||||
//
|
||||
// Returns the lower 64-bit value of a `int128` value.
|
||||
friend constexpr uint64_t Int128Low64(int128 v);
|
||||
|
||||
// Int128High64()
|
||||
//
|
||||
// Returns the higher 64-bit value of a `int128` value.
|
||||
friend constexpr int64_t Int128High64(int128 v);
|
||||
|
||||
// MakeInt128()
|
||||
//
|
||||
// Constructs a `int128` numeric value from two 64-bit integers. Note that
|
||||
// signedness is conveyed in the upper `high` value.
|
||||
//
|
||||
// (absl::int128(1) << 64) * high + low
|
||||
//
|
||||
// Note that this factory function is the only way to construct a `int128`
|
||||
// from integer values greater than 2^64 or less than -2^64.
|
||||
//
|
||||
// Example:
|
||||
//
|
||||
// absl::int128 big = absl::MakeInt128(1, 0);
|
||||
// absl::int128 big_n = absl::MakeInt128(-1, 0);
|
||||
friend constexpr int128 MakeInt128(int64_t high, uint64_t low);
|
||||
|
||||
// Int128Max()
|
||||
//
|
||||
// Returns the maximum value for a 128-bit signed integer.
|
||||
friend constexpr int128 Int128Max();
|
||||
|
||||
// Int128Min()
|
||||
//
|
||||
// Returns the minimum value for a 128-bit signed integer.
|
||||
friend constexpr int128 Int128Min();
|
||||
|
||||
// Support for absl::Hash.
|
||||
template <typename H>
|
||||
friend H AbslHashValue(H h, int128 v) {
|
||||
return H::combine(std::move(h), Int128High64(v), Int128Low64(v));
|
||||
}
|
||||
|
||||
private:
|
||||
constexpr int128(int64_t high, uint64_t low);
|
||||
|
||||
#if defined(ABSL_HAVE_INTRINSIC_INT128)
|
||||
__int128 v_;
|
||||
#else // ABSL_HAVE_INTRINSIC_INT128
|
||||
#if defined(ABSL_IS_LITTLE_ENDIAN)
|
||||
uint64_t lo_;
|
||||
int64_t hi_;
|
||||
#elif defined(ABSL_IS_BIG_ENDIAN)
|
||||
int64_t hi_;
|
||||
uint64_t lo_;
|
||||
#else // byte order
|
||||
#error "Unsupported byte order: must be little-endian or big-endian."
|
||||
#endif // byte order
|
||||
#endif // ABSL_HAVE_INTRINSIC_INT128
|
||||
};
|
||||
|
||||
std::ostream& operator<<(std::ostream& os, int128 v);
|
||||
|
||||
// TODO(absl-team) add operator>>(std::istream&, int128)
|
||||
|
||||
constexpr int128 Int128Max() {
|
||||
return int128((std::numeric_limits<int64_t>::max)(),
|
||||
(std::numeric_limits<uint64_t>::max)());
|
||||
}
|
||||
|
||||
constexpr int128 Int128Min() {
|
||||
return int128((std::numeric_limits<int64_t>::min)(), 0);
|
||||
}
|
||||
|
||||
} // namespace absl
|
||||
|
||||
// Specialized numeric_limits for int128.
|
||||
namespace std {
|
||||
template <>
|
||||
class numeric_limits<absl::int128> {
|
||||
public:
|
||||
static constexpr bool is_specialized = true;
|
||||
static constexpr bool is_signed = true;
|
||||
static constexpr bool is_integer = true;
|
||||
static constexpr bool is_exact = true;
|
||||
static constexpr bool has_infinity = false;
|
||||
static constexpr bool has_quiet_NaN = false;
|
||||
static constexpr bool has_signaling_NaN = false;
|
||||
static constexpr float_denorm_style has_denorm = denorm_absent;
|
||||
static constexpr bool has_denorm_loss = false;
|
||||
static constexpr float_round_style round_style = round_toward_zero;
|
||||
static constexpr bool is_iec559 = false;
|
||||
static constexpr bool is_bounded = true;
|
||||
static constexpr bool is_modulo = false;
|
||||
static constexpr int digits = 127;
|
||||
static constexpr int digits10 = 38;
|
||||
static constexpr int max_digits10 = 0;
|
||||
static constexpr int radix = 2;
|
||||
static constexpr int min_exponent = 0;
|
||||
static constexpr int min_exponent10 = 0;
|
||||
static constexpr int max_exponent = 0;
|
||||
static constexpr int max_exponent10 = 0;
|
||||
#ifdef ABSL_HAVE_INTRINSIC_INT128
|
||||
static constexpr bool traps = numeric_limits<__int128>::traps;
|
||||
#else // ABSL_HAVE_INTRINSIC_INT128
|
||||
static constexpr bool traps = numeric_limits<uint64_t>::traps;
|
||||
#endif // ABSL_HAVE_INTRINSIC_INT128
|
||||
static constexpr bool tinyness_before = false;
|
||||
|
||||
static constexpr absl::int128 (min)() { return absl::Int128Min(); }
|
||||
static constexpr absl::int128 lowest() { return absl::Int128Min(); }
|
||||
static constexpr absl::int128 (max)() { return absl::Int128Max(); }
|
||||
static constexpr absl::int128 epsilon() { return 0; }
|
||||
static constexpr absl::int128 round_error() { return 0; }
|
||||
static constexpr absl::int128 infinity() { return 0; }
|
||||
static constexpr absl::int128 quiet_NaN() { return 0; }
|
||||
static constexpr absl::int128 signaling_NaN() { return 0; }
|
||||
static constexpr absl::int128 denorm_min() { return 0; }
|
||||
};
|
||||
} // namespace std
|
||||
|
||||
// --------------------------------------------------------------------------
|
||||
// Implementation details follow
|
||||
|
|
@ -339,6 +571,10 @@ inline uint128& uint128::operator=(unsigned __int128 v) {
|
|||
}
|
||||
#endif // ABSL_HAVE_INTRINSIC_INT128
|
||||
|
||||
inline uint128& uint128::operator=(int128 v) {
|
||||
return *this = uint128(v);
|
||||
}
|
||||
|
||||
// Arithmetic operators.
|
||||
|
||||
uint128 operator<<(uint128 lhs, int amount);
|
||||
|
|
@ -420,6 +656,9 @@ constexpr uint128::uint128(unsigned __int128 v)
|
|||
hi_{static_cast<uint64_t>(v >> 64)} {}
|
||||
#endif // ABSL_HAVE_INTRINSIC_INT128
|
||||
|
||||
constexpr uint128::uint128(int128 v)
|
||||
: lo_{Int128Low64(v)}, hi_{static_cast<uint64_t>(Int128High64(v))} {}
|
||||
|
||||
#elif defined(ABSL_IS_BIG_ENDIAN)
|
||||
|
||||
constexpr uint128::uint128(uint64_t high, uint64_t low)
|
||||
|
|
@ -450,6 +689,9 @@ constexpr uint128::uint128(unsigned __int128 v)
|
|||
lo_{static_cast<uint64_t>(v & ~uint64_t{0})} {}
|
||||
#endif // ABSL_HAVE_INTRINSIC_INT128
|
||||
|
||||
constexpr uint128::uint128(int128 v)
|
||||
: hi_{static_cast<uint64_t>(Int128High64(v))}, lo_{Int128Low64(v)} {}
|
||||
|
||||
#else // byte order
|
||||
#error "Unsupported byte order: must be little-endian or big-endian."
|
||||
#endif // byte order
|
||||
|
|
@ -719,6 +961,117 @@ inline uint128& uint128::operator--() {
|
|||
return *this;
|
||||
}
|
||||
|
||||
constexpr int128 MakeInt128(int64_t high, uint64_t low) {
|
||||
return int128(high, low);
|
||||
}
|
||||
|
||||
// Assignment from integer types.
|
||||
inline int128& int128::operator=(int v) {
|
||||
return *this = int128(v);
|
||||
}
|
||||
|
||||
inline int128& int128::operator=(unsigned int v) {
|
||||
return *this = int128(v);
|
||||
}
|
||||
|
||||
inline int128& int128::operator=(long v) { // NOLINT(runtime/int)
|
||||
return *this = int128(v);
|
||||
}
|
||||
|
||||
// NOLINTNEXTLINE(runtime/int)
|
||||
inline int128& int128::operator=(unsigned long v) {
|
||||
return *this = int128(v);
|
||||
}
|
||||
|
||||
// NOLINTNEXTLINE(runtime/int)
|
||||
inline int128& int128::operator=(long long v) {
|
||||
return *this = int128(v);
|
||||
}
|
||||
|
||||
// NOLINTNEXTLINE(runtime/int)
|
||||
inline int128& int128::operator=(unsigned long long v) {
|
||||
return *this = int128(v);
|
||||
}
|
||||
|
||||
// Arithmetic operators.
|
||||
|
||||
int128 operator+(int128 lhs, int128 rhs);
|
||||
int128 operator-(int128 lhs, int128 rhs);
|
||||
int128 operator*(int128 lhs, int128 rhs);
|
||||
int128 operator/(int128 lhs, int128 rhs);
|
||||
int128 operator%(int128 lhs, int128 rhs);
|
||||
int128 operator|(int128 lhs, int128 rhs);
|
||||
int128 operator&(int128 lhs, int128 rhs);
|
||||
int128 operator^(int128 lhs, int128 rhs);
|
||||
int128 operator<<(int128 lhs, int amount);
|
||||
int128 operator>>(int128 lhs, int amount);
|
||||
|
||||
inline int128& int128::operator+=(int128 other) {
|
||||
*this = *this + other;
|
||||
return *this;
|
||||
}
|
||||
|
||||
inline int128& int128::operator-=(int128 other) {
|
||||
*this = *this - other;
|
||||
return *this;
|
||||
}
|
||||
|
||||
inline int128& int128::operator*=(int128 other) {
|
||||
*this = *this * other;
|
||||
return *this;
|
||||
}
|
||||
|
||||
inline int128& int128::operator/=(int128 other) {
|
||||
*this = *this / other;
|
||||
return *this;
|
||||
}
|
||||
|
||||
inline int128& int128::operator%=(int128 other) {
|
||||
*this = *this % other;
|
||||
return *this;
|
||||
}
|
||||
|
||||
inline int128& int128::operator|=(int128 other) {
|
||||
*this = *this | other;
|
||||
return *this;
|
||||
}
|
||||
|
||||
inline int128& int128::operator&=(int128 other) {
|
||||
*this = *this & other;
|
||||
return *this;
|
||||
}
|
||||
|
||||
inline int128& int128::operator^=(int128 other) {
|
||||
*this = *this ^ other;
|
||||
return *this;
|
||||
}
|
||||
|
||||
inline int128& int128::operator<<=(int amount) {
|
||||
*this = *this << amount;
|
||||
return *this;
|
||||
}
|
||||
|
||||
inline int128& int128::operator>>=(int amount) {
|
||||
*this = *this >> amount;
|
||||
return *this;
|
||||
}
|
||||
|
||||
namespace int128_internal {
|
||||
|
||||
// Casts from unsigned to signed while preserving the underlying binary
|
||||
// representation.
|
||||
constexpr int64_t BitCastToSigned(uint64_t v) {
|
||||
// Casting an unsigned integer to a signed integer of the same
|
||||
// width is implementation defined behavior if the source value would not fit
|
||||
// in the destination type. We step around it with a roundtrip bitwise not
|
||||
// operation to make sure this function remains constexpr. Clang, GCC, and
|
||||
// MSVC optimize this to a no-op on x86-64.
|
||||
return v & (uint64_t{1} << 63) ? ~static_cast<int64_t>(~v)
|
||||
: static_cast<int64_t>(v);
|
||||
}
|
||||
|
||||
} // namespace int128_internal
|
||||
|
||||
#if defined(ABSL_HAVE_INTRINSIC_INT128)
|
||||
#include "absl/numeric/int128_have_intrinsic.inc" // IWYU pragma: export
|
||||
#else // ABSL_HAVE_INTRINSIC_INT128
|
||||
|
|
|
|||
|
|
@ -16,3 +16,287 @@
|
|||
// This file contains :int128 implementation details that depend on internal
|
||||
// representation when ABSL_HAVE_INTRINSIC_INT128 is defined. This file is
|
||||
// included by int128.h and relies on ABSL_INTERNAL_WCHAR_T being defined.
|
||||
|
||||
namespace int128_internal {
|
||||
|
||||
// Casts from unsigned to signed while preserving the underlying binary
|
||||
// representation.
|
||||
constexpr __int128 BitCastToSigned(unsigned __int128 v) {
|
||||
// Casting an unsigned integer to a signed integer of the same
|
||||
// width is implementation defined behavior if the source value would not fit
|
||||
// in the destination type. We step around it with a roundtrip bitwise not
|
||||
// operation to make sure this function remains constexpr. Clang and GCC
|
||||
// optimize this to a no-op on x86-64.
|
||||
return v & (static_cast<unsigned __int128>(1) << 127)
|
||||
? ~static_cast<__int128>(~v)
|
||||
: static_cast<__int128>(v);
|
||||
}
|
||||
|
||||
} // namespace int128_internal
|
||||
|
||||
inline int128& int128::operator=(__int128 v) {
|
||||
v_ = v;
|
||||
return *this;
|
||||
}
|
||||
|
||||
constexpr uint64_t Int128Low64(int128 v) {
|
||||
return static_cast<uint64_t>(v.v_ & ~uint64_t{0});
|
||||
}
|
||||
|
||||
constexpr int64_t Int128High64(int128 v) {
|
||||
// Initially cast to unsigned to prevent a right shift on a negative value.
|
||||
return int128_internal::BitCastToSigned(
|
||||
static_cast<uint64_t>(static_cast<unsigned __int128>(v.v_) >> 64));
|
||||
}
|
||||
|
||||
constexpr int128::int128(int64_t high, uint64_t low)
|
||||
// Initially cast to unsigned to prevent a left shift that overflows.
|
||||
: v_(int128_internal::BitCastToSigned(static_cast<unsigned __int128>(high)
|
||||
<< 64) |
|
||||
low) {}
|
||||
|
||||
|
||||
constexpr int128::int128(int v) : v_{v} {}
|
||||
|
||||
constexpr int128::int128(long v) : v_{v} {} // NOLINT(runtime/int)
|
||||
|
||||
constexpr int128::int128(long long v) : v_{v} {} // NOLINT(runtime/int)
|
||||
|
||||
constexpr int128::int128(__int128 v) : v_{v} {}
|
||||
|
||||
constexpr int128::int128(unsigned int v) : v_{v} {}
|
||||
|
||||
constexpr int128::int128(unsigned long v) : v_{v} {} // NOLINT(runtime/int)
|
||||
|
||||
// NOLINTNEXTLINE(runtime/int)
|
||||
constexpr int128::int128(unsigned long long v) : v_{v} {}
|
||||
|
||||
constexpr int128::int128(unsigned __int128 v) : v_{static_cast<__int128>(v)} {}
|
||||
|
||||
inline int128::int128(float v) {
|
||||
v_ = static_cast<__int128>(v);
|
||||
}
|
||||
|
||||
inline int128::int128(double v) {
|
||||
v_ = static_cast<__int128>(v);
|
||||
}
|
||||
|
||||
inline int128::int128(long double v) {
|
||||
v_ = static_cast<__int128>(v);
|
||||
}
|
||||
|
||||
constexpr int128::int128(uint128 v) : v_{static_cast<__int128>(v)} {}
|
||||
|
||||
constexpr int128::operator bool() const { return static_cast<bool>(v_); }
|
||||
|
||||
constexpr int128::operator char() const { return static_cast<char>(v_); }
|
||||
|
||||
constexpr int128::operator signed char() const {
|
||||
return static_cast<signed char>(v_);
|
||||
}
|
||||
|
||||
constexpr int128::operator unsigned char() const {
|
||||
return static_cast<unsigned char>(v_);
|
||||
}
|
||||
|
||||
constexpr int128::operator char16_t() const {
|
||||
return static_cast<char16_t>(v_);
|
||||
}
|
||||
|
||||
constexpr int128::operator char32_t() const {
|
||||
return static_cast<char32_t>(v_);
|
||||
}
|
||||
|
||||
constexpr int128::operator ABSL_INTERNAL_WCHAR_T() const {
|
||||
return static_cast<ABSL_INTERNAL_WCHAR_T>(v_);
|
||||
}
|
||||
|
||||
constexpr int128::operator short() const { // NOLINT(runtime/int)
|
||||
return static_cast<short>(v_); // NOLINT(runtime/int)
|
||||
}
|
||||
|
||||
constexpr int128::operator unsigned short() const { // NOLINT(runtime/int)
|
||||
return static_cast<unsigned short>(v_); // NOLINT(runtime/int)
|
||||
}
|
||||
|
||||
constexpr int128::operator int() const {
|
||||
return static_cast<int>(v_);
|
||||
}
|
||||
|
||||
constexpr int128::operator unsigned int() const {
|
||||
return static_cast<unsigned int>(v_);
|
||||
}
|
||||
|
||||
constexpr int128::operator long() const { // NOLINT(runtime/int)
|
||||
return static_cast<long>(v_); // NOLINT(runtime/int)
|
||||
}
|
||||
|
||||
constexpr int128::operator unsigned long() const { // NOLINT(runtime/int)
|
||||
return static_cast<unsigned long>(v_); // NOLINT(runtime/int)
|
||||
}
|
||||
|
||||
constexpr int128::operator long long() const { // NOLINT(runtime/int)
|
||||
return static_cast<long long>(v_); // NOLINT(runtime/int)
|
||||
}
|
||||
|
||||
constexpr int128::operator unsigned long long() const { // NOLINT(runtime/int)
|
||||
return static_cast<unsigned long long>(v_); // NOLINT(runtime/int)
|
||||
}
|
||||
|
||||
constexpr int128::operator __int128() const { return v_; }
|
||||
|
||||
constexpr int128::operator unsigned __int128() const {
|
||||
return static_cast<unsigned __int128>(v_);
|
||||
}
|
||||
|
||||
// Clang on PowerPC sometimes produces incorrect __int128 to floating point
|
||||
// conversions. In that case, we do the conversion with a similar implementation
|
||||
// to the conversion operators in int128_no_intrinsic.inc.
|
||||
#if defined(__clang__) && !defined(__ppc64__)
|
||||
inline int128::operator float() const { return static_cast<float>(v_); }
|
||||
|
||||
inline int128::operator double () const { return static_cast<double>(v_); }
|
||||
|
||||
inline int128::operator long double() const {
|
||||
return static_cast<long double>(v_);
|
||||
}
|
||||
|
||||
#else // Clang on PowerPC
|
||||
// Forward declaration for conversion operators to floating point types.
|
||||
int128 operator-(int128 v);
|
||||
bool operator!=(int128 lhs, int128 rhs);
|
||||
|
||||
inline int128::operator float() const {
|
||||
// We must convert the absolute value and then negate as needed, because
|
||||
// floating point types are typically sign-magnitude. Otherwise, the
|
||||
// difference between the high and low 64 bits when interpreted as two's
|
||||
// complement overwhelms the precision of the mantissa.
|
||||
//
|
||||
// Also check to make sure we don't negate Int128Min()
|
||||
return v_ < 0 && *this != Int128Min()
|
||||
? -static_cast<float>(-*this)
|
||||
: static_cast<float>(Int128Low64(*this)) +
|
||||
std::ldexp(static_cast<float>(Int128High64(*this)), 64);
|
||||
}
|
||||
|
||||
inline int128::operator double() const {
|
||||
// See comment in int128::operator float() above.
|
||||
return v_ < 0 && *this != Int128Min()
|
||||
? -static_cast<double>(-*this)
|
||||
: static_cast<double>(Int128Low64(*this)) +
|
||||
std::ldexp(static_cast<double>(Int128High64(*this)), 64);
|
||||
}
|
||||
|
||||
inline int128::operator long double() const {
|
||||
// See comment in int128::operator float() above.
|
||||
return v_ < 0 && *this != Int128Min()
|
||||
? -static_cast<long double>(-*this)
|
||||
: static_cast<long double>(Int128Low64(*this)) +
|
||||
std::ldexp(static_cast<long double>(Int128High64(*this)),
|
||||
64);
|
||||
}
|
||||
#endif // Clang on PowerPC
|
||||
|
||||
// Comparison operators.
|
||||
|
||||
inline bool operator==(int128 lhs, int128 rhs) {
|
||||
return static_cast<__int128>(lhs) == static_cast<__int128>(rhs);
|
||||
}
|
||||
|
||||
inline bool operator!=(int128 lhs, int128 rhs) {
|
||||
return static_cast<__int128>(lhs) != static_cast<__int128>(rhs);
|
||||
}
|
||||
|
||||
inline bool operator<(int128 lhs, int128 rhs) {
|
||||
return static_cast<__int128>(lhs) < static_cast<__int128>(rhs);
|
||||
}
|
||||
|
||||
inline bool operator>(int128 lhs, int128 rhs) {
|
||||
return static_cast<__int128>(lhs) > static_cast<__int128>(rhs);
|
||||
}
|
||||
|
||||
inline bool operator<=(int128 lhs, int128 rhs) {
|
||||
return static_cast<__int128>(lhs) <= static_cast<__int128>(rhs);
|
||||
}
|
||||
|
||||
inline bool operator>=(int128 lhs, int128 rhs) {
|
||||
return static_cast<__int128>(lhs) >= static_cast<__int128>(rhs);
|
||||
}
|
||||
|
||||
// Unary operators.
|
||||
|
||||
inline int128 operator-(int128 v) {
|
||||
return -static_cast<__int128>(v);
|
||||
}
|
||||
|
||||
inline bool operator!(int128 v) {
|
||||
return !static_cast<__int128>(v);
|
||||
}
|
||||
|
||||
inline int128 operator~(int128 val) {
|
||||
return ~static_cast<__int128>(val);
|
||||
}
|
||||
|
||||
// Arithmetic operators.
|
||||
|
||||
inline int128 operator+(int128 lhs, int128 rhs) {
|
||||
return static_cast<__int128>(lhs) + static_cast<__int128>(rhs);
|
||||
}
|
||||
|
||||
inline int128 operator-(int128 lhs, int128 rhs) {
|
||||
return static_cast<__int128>(lhs) - static_cast<__int128>(rhs);
|
||||
}
|
||||
|
||||
inline int128 operator*(int128 lhs, int128 rhs) {
|
||||
return static_cast<__int128>(lhs) * static_cast<__int128>(rhs);
|
||||
}
|
||||
|
||||
inline int128 operator/(int128 lhs, int128 rhs) {
|
||||
return static_cast<__int128>(lhs) / static_cast<__int128>(rhs);
|
||||
}
|
||||
|
||||
inline int128 operator%(int128 lhs, int128 rhs) {
|
||||
return static_cast<__int128>(lhs) % static_cast<__int128>(rhs);
|
||||
}
|
||||
|
||||
inline int128 int128::operator++(int) {
|
||||
int128 tmp(*this);
|
||||
++v_;
|
||||
return tmp;
|
||||
}
|
||||
|
||||
inline int128 int128::operator--(int) {
|
||||
int128 tmp(*this);
|
||||
--v_;
|
||||
return tmp;
|
||||
}
|
||||
|
||||
inline int128& int128::operator++() {
|
||||
++v_;
|
||||
return *this;
|
||||
}
|
||||
|
||||
inline int128& int128::operator--() {
|
||||
--v_;
|
||||
return *this;
|
||||
}
|
||||
|
||||
inline int128 operator|(int128 lhs, int128 rhs) {
|
||||
return static_cast<__int128>(lhs) | static_cast<__int128>(rhs);
|
||||
}
|
||||
|
||||
inline int128 operator&(int128 lhs, int128 rhs) {
|
||||
return static_cast<__int128>(lhs) & static_cast<__int128>(rhs);
|
||||
}
|
||||
|
||||
inline int128 operator^(int128 lhs, int128 rhs) {
|
||||
return static_cast<__int128>(lhs) ^ static_cast<__int128>(rhs);
|
||||
}
|
||||
|
||||
inline int128 operator<<(int128 lhs, int amount) {
|
||||
return static_cast<__int128>(lhs) << amount;
|
||||
}
|
||||
|
||||
inline int128 operator>>(int128 lhs, int amount) {
|
||||
return static_cast<__int128>(lhs) >> amount;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -16,3 +16,293 @@
|
|||
// This file contains :int128 implementation details that depend on internal
|
||||
// representation when ABSL_HAVE_INTRINSIC_INT128 is *not* defined. This file
|
||||
// is included by int128.h and relies on ABSL_INTERNAL_WCHAR_T being defined.
|
||||
|
||||
constexpr uint64_t Int128Low64(int128 v) { return v.lo_; }
|
||||
|
||||
constexpr int64_t Int128High64(int128 v) { return v.hi_; }
|
||||
|
||||
#if defined(ABSL_IS_LITTLE_ENDIAN)
|
||||
|
||||
constexpr int128::int128(int64_t high, uint64_t low) :
|
||||
lo_(low), hi_(high) {}
|
||||
|
||||
constexpr int128::int128(int v)
|
||||
: lo_{static_cast<uint64_t>(v)}, hi_{v < 0 ? ~int64_t{0} : 0} {}
|
||||
constexpr int128::int128(long v) // NOLINT(runtime/int)
|
||||
: lo_{static_cast<uint64_t>(v)}, hi_{v < 0 ? ~int64_t{0} : 0} {}
|
||||
constexpr int128::int128(long long v) // NOLINT(runtime/int)
|
||||
: lo_{static_cast<uint64_t>(v)}, hi_{v < 0 ? ~int64_t{0} : 0} {}
|
||||
|
||||
constexpr int128::int128(unsigned int v) : lo_{v}, hi_{0} {}
|
||||
// NOLINTNEXTLINE(runtime/int)
|
||||
constexpr int128::int128(unsigned long v) : lo_{v}, hi_{0} {}
|
||||
// NOLINTNEXTLINE(runtime/int)
|
||||
constexpr int128::int128(unsigned long long v) : lo_{v}, hi_{0} {}
|
||||
|
||||
constexpr int128::int128(uint128 v)
|
||||
: lo_{Uint128Low64(v)}, hi_{static_cast<int64_t>(Uint128High64(v))} {}
|
||||
|
||||
#elif defined(ABSL_IS_BIG_ENDIAN)
|
||||
|
||||
constexpr int128::int128(int64_t high, uint64_t low) :
|
||||
hi_{high}, lo_{low} {}
|
||||
|
||||
constexpr int128::int128(int v)
|
||||
: hi_{v < 0 ? ~int64_t{0} : 0}, lo_{static_cast<uint64_t>(v)} {}
|
||||
constexpr int128::int128(long v) // NOLINT(runtime/int)
|
||||
: hi_{v < 0 ? ~int64_t{0} : 0}, lo_{static_cast<uint64_t>(v)} {}
|
||||
constexpr int128::int128(long long v) // NOLINT(runtime/int)
|
||||
: hi_{v < 0 ? ~int64_t{0} : 0}, lo_{static_cast<uint64_t>(v)} {}
|
||||
|
||||
constexpr int128::int128(unsigned int v) : hi_{0}, lo_{v} {}
|
||||
// NOLINTNEXTLINE(runtime/int)
|
||||
constexpr int128::int128(unsigned long v) : hi_{0}, lo_{v} {}
|
||||
// NOLINTNEXTLINE(runtime/int)
|
||||
constexpr int128::int128(unsigned long long v) : hi_{0}, lo_{v} {}
|
||||
|
||||
constexpr int128::int128(uint128 v)
|
||||
: hi_{static_cast<int64_t>(Uint128High64(v))}, lo_{Uint128Low64(v)} {}
|
||||
|
||||
#else // byte order
|
||||
#error "Unsupported byte order: must be little-endian or big-endian."
|
||||
#endif // byte order
|
||||
|
||||
constexpr int128::operator bool() const { return lo_ || hi_; }
|
||||
|
||||
constexpr int128::operator char() const {
|
||||
// NOLINTNEXTLINE(runtime/int)
|
||||
return static_cast<char>(static_cast<long long>(*this));
|
||||
}
|
||||
|
||||
constexpr int128::operator signed char() const {
|
||||
// NOLINTNEXTLINE(runtime/int)
|
||||
return static_cast<signed char>(static_cast<long long>(*this));
|
||||
}
|
||||
|
||||
constexpr int128::operator unsigned char() const {
|
||||
return static_cast<unsigned char>(lo_);
|
||||
}
|
||||
|
||||
constexpr int128::operator char16_t() const {
|
||||
return static_cast<char16_t>(lo_);
|
||||
}
|
||||
|
||||
constexpr int128::operator char32_t() const {
|
||||
return static_cast<char32_t>(lo_);
|
||||
}
|
||||
|
||||
constexpr int128::operator ABSL_INTERNAL_WCHAR_T() const {
|
||||
// NOLINTNEXTLINE(runtime/int)
|
||||
return static_cast<ABSL_INTERNAL_WCHAR_T>(static_cast<long long>(*this));
|
||||
}
|
||||
|
||||
constexpr int128::operator short() const { // NOLINT(runtime/int)
|
||||
// NOLINTNEXTLINE(runtime/int)
|
||||
return static_cast<short>(static_cast<long long>(*this));
|
||||
}
|
||||
|
||||
constexpr int128::operator unsigned short() const { // NOLINT(runtime/int)
|
||||
return static_cast<unsigned short>(lo_); // NOLINT(runtime/int)
|
||||
}
|
||||
|
||||
constexpr int128::operator int() const {
|
||||
// NOLINTNEXTLINE(runtime/int)
|
||||
return static_cast<int>(static_cast<long long>(*this));
|
||||
}
|
||||
|
||||
constexpr int128::operator unsigned int() const {
|
||||
return static_cast<unsigned int>(lo_);
|
||||
}
|
||||
|
||||
constexpr int128::operator long() const { // NOLINT(runtime/int)
|
||||
// NOLINTNEXTLINE(runtime/int)
|
||||
return static_cast<long>(static_cast<long long>(*this));
|
||||
}
|
||||
|
||||
constexpr int128::operator unsigned long() const { // NOLINT(runtime/int)
|
||||
return static_cast<unsigned long>(lo_); // NOLINT(runtime/int)
|
||||
}
|
||||
|
||||
constexpr int128::operator long long() const { // NOLINT(runtime/int)
|
||||
// We don't bother checking the value of hi_. If *this < 0, lo_'s high bit
|
||||
// must be set in order for the value to fit into a long long. Conversely, if
|
||||
// lo_'s high bit is set, *this must be < 0 for the value to fit.
|
||||
return int128_internal::BitCastToSigned(lo_);
|
||||
}
|
||||
|
||||
constexpr int128::operator unsigned long long() const { // NOLINT(runtime/int)
|
||||
return static_cast<unsigned long long>(lo_); // NOLINT(runtime/int)
|
||||
}
|
||||
|
||||
// Forward declaration for conversion operators to floating point types.
|
||||
int128 operator-(int128 v);
|
||||
bool operator!=(int128 lhs, int128 rhs);
|
||||
|
||||
inline int128::operator float() const {
|
||||
// We must convert the absolute value and then negate as needed, because
|
||||
// floating point types are typically sign-magnitude. Otherwise, the
|
||||
// difference between the high and low 64 bits when interpreted as two's
|
||||
// complement overwhelms the precision of the mantissa.
|
||||
//
|
||||
// Also check to make sure we don't negate Int128Min()
|
||||
return hi_ < 0 && *this != Int128Min()
|
||||
? -static_cast<float>(-*this)
|
||||
: static_cast<float>(lo_) +
|
||||
std::ldexp(static_cast<float>(hi_), 64);
|
||||
}
|
||||
|
||||
inline int128::operator double() const {
|
||||
// See comment in int128::operator float() above.
|
||||
return hi_ < 0 && *this != Int128Min()
|
||||
? -static_cast<double>(-*this)
|
||||
: static_cast<double>(lo_) +
|
||||
std::ldexp(static_cast<double>(hi_), 64);
|
||||
}
|
||||
|
||||
inline int128::operator long double() const {
|
||||
// See comment in int128::operator float() above.
|
||||
return hi_ < 0 && *this != Int128Min()
|
||||
? -static_cast<long double>(-*this)
|
||||
: static_cast<long double>(lo_) +
|
||||
std::ldexp(static_cast<long double>(hi_), 64);
|
||||
}
|
||||
|
||||
// Comparison operators.
|
||||
|
||||
inline bool operator==(int128 lhs, int128 rhs) {
|
||||
return (Int128Low64(lhs) == Int128Low64(rhs) &&
|
||||
Int128High64(lhs) == Int128High64(rhs));
|
||||
}
|
||||
|
||||
inline bool operator!=(int128 lhs, int128 rhs) {
|
||||
return !(lhs == rhs);
|
||||
}
|
||||
|
||||
inline bool operator<(int128 lhs, int128 rhs) {
|
||||
return (Int128High64(lhs) == Int128High64(rhs))
|
||||
? (Int128Low64(lhs) < Int128Low64(rhs))
|
||||
: (Int128High64(lhs) < Int128High64(rhs));
|
||||
}
|
||||
|
||||
inline bool operator>(int128 lhs, int128 rhs) {
|
||||
return (Int128High64(lhs) == Int128High64(rhs))
|
||||
? (Int128Low64(lhs) > Int128Low64(rhs))
|
||||
: (Int128High64(lhs) > Int128High64(rhs));
|
||||
}
|
||||
|
||||
inline bool operator<=(int128 lhs, int128 rhs) {
|
||||
return !(lhs > rhs);
|
||||
}
|
||||
|
||||
inline bool operator>=(int128 lhs, int128 rhs) {
|
||||
return !(lhs < rhs);
|
||||
}
|
||||
|
||||
// Unary operators.
|
||||
|
||||
inline int128 operator-(int128 v) {
|
||||
int64_t hi = ~Int128High64(v);
|
||||
uint64_t lo = ~Int128Low64(v) + 1;
|
||||
if (lo == 0) ++hi; // carry
|
||||
return MakeInt128(hi, lo);
|
||||
}
|
||||
|
||||
inline bool operator!(int128 v) {
|
||||
return !Int128Low64(v) && !Int128High64(v);
|
||||
}
|
||||
|
||||
inline int128 operator~(int128 val) {
|
||||
return MakeInt128(~Int128High64(val), ~Int128Low64(val));
|
||||
}
|
||||
|
||||
// Arithmetic operators.
|
||||
|
||||
inline int128 operator+(int128 lhs, int128 rhs) {
|
||||
int128 result = MakeInt128(Int128High64(lhs) + Int128High64(rhs),
|
||||
Int128Low64(lhs) + Int128Low64(rhs));
|
||||
if (Int128Low64(result) < Int128Low64(lhs)) { // check for carry
|
||||
return MakeInt128(Int128High64(result) + 1, Int128Low64(result));
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
inline int128 operator-(int128 lhs, int128 rhs) {
|
||||
int128 result = MakeInt128(Int128High64(lhs) - Int128High64(rhs),
|
||||
Int128Low64(lhs) - Int128Low64(rhs));
|
||||
if (Int128Low64(lhs) < Int128Low64(rhs)) { // check for carry
|
||||
return MakeInt128(Int128High64(result) - 1, Int128Low64(result));
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
inline int128 operator*(int128 lhs, int128 rhs) {
|
||||
uint128 result = uint128(lhs) * rhs;
|
||||
return MakeInt128(int128_internal::BitCastToSigned(Uint128High64(result)),
|
||||
Uint128Low64(result));
|
||||
}
|
||||
|
||||
inline int128 int128::operator++(int) {
|
||||
int128 tmp(*this);
|
||||
*this += 1;
|
||||
return tmp;
|
||||
}
|
||||
|
||||
inline int128 int128::operator--(int) {
|
||||
int128 tmp(*this);
|
||||
*this -= 1;
|
||||
return tmp;
|
||||
}
|
||||
|
||||
inline int128& int128::operator++() {
|
||||
*this += 1;
|
||||
return *this;
|
||||
}
|
||||
|
||||
inline int128& int128::operator--() {
|
||||
*this -= 1;
|
||||
return *this;
|
||||
}
|
||||
|
||||
inline int128 operator|(int128 lhs, int128 rhs) {
|
||||
return MakeInt128(Int128High64(lhs) | Int128High64(rhs),
|
||||
Int128Low64(lhs) | Int128Low64(rhs));
|
||||
}
|
||||
|
||||
inline int128 operator&(int128 lhs, int128 rhs) {
|
||||
return MakeInt128(Int128High64(lhs) & Int128High64(rhs),
|
||||
Int128Low64(lhs) & Int128Low64(rhs));
|
||||
}
|
||||
|
||||
inline int128 operator^(int128 lhs, int128 rhs) {
|
||||
return MakeInt128(Int128High64(lhs) ^ Int128High64(rhs),
|
||||
Int128Low64(lhs) ^ Int128Low64(rhs));
|
||||
}
|
||||
|
||||
inline int128 operator<<(int128 lhs, int amount) {
|
||||
// uint64_t shifts of >= 64 are undefined, so we need some special-casing.
|
||||
if (amount < 64) {
|
||||
if (amount != 0) {
|
||||
return MakeInt128(
|
||||
(Int128High64(lhs) << amount) |
|
||||
static_cast<int64_t>(Int128Low64(lhs) >> (64 - amount)),
|
||||
Int128Low64(lhs) << amount);
|
||||
}
|
||||
return lhs;
|
||||
}
|
||||
return MakeInt128(static_cast<int64_t>(Int128Low64(lhs) << (amount - 64)), 0);
|
||||
}
|
||||
|
||||
inline int128 operator>>(int128 lhs, int amount) {
|
||||
// uint64_t shifts of >= 64 are undefined, so we need some special-casing.
|
||||
if (amount < 64) {
|
||||
if (amount != 0) {
|
||||
return MakeInt128(
|
||||
Int128High64(lhs) >> amount,
|
||||
(Int128Low64(lhs) >> amount) |
|
||||
(static_cast<uint64_t>(Int128High64(lhs)) << (64 - amount)));
|
||||
}
|
||||
return lhs;
|
||||
}
|
||||
return MakeInt128(0,
|
||||
static_cast<uint64_t>(Int128High64(lhs) >> (amount - 64)));
|
||||
}
|
||||
|
|
|
|||
|
|
@ -147,6 +147,735 @@ TEST(Uint128, OStreamFormatTest) {
|
|||
}
|
||||
}
|
||||
|
||||
struct Int128TestCase {
|
||||
absl::int128 value;
|
||||
std::ios_base::fmtflags flags;
|
||||
std::streamsize width;
|
||||
const char* expected;
|
||||
};
|
||||
|
||||
void CheckInt128Case(const Int128TestCase& test_case) {
|
||||
std::ostringstream os;
|
||||
os.flags(test_case.flags);
|
||||
os.width(test_case.width);
|
||||
os.fill(kFill);
|
||||
os << test_case.value;
|
||||
SCOPED_TRACE(StreamFormatToString(test_case.flags, test_case.width));
|
||||
EXPECT_EQ(test_case.expected, os.str());
|
||||
}
|
||||
|
||||
TEST(Int128, OStreamValueTest) {
|
||||
CheckInt128Case({1, kDec, /*width = */ 0, "1"});
|
||||
CheckInt128Case({1, kOct, /*width = */ 0, "1"});
|
||||
CheckInt128Case({1, kHex, /*width = */ 0, "1"});
|
||||
CheckInt128Case({9, kDec, /*width = */ 0, "9"});
|
||||
CheckInt128Case({9, kOct, /*width = */ 0, "11"});
|
||||
CheckInt128Case({9, kHex, /*width = */ 0, "9"});
|
||||
CheckInt128Case({12345, kDec, /*width = */ 0, "12345"});
|
||||
CheckInt128Case({12345, kOct, /*width = */ 0, "30071"});
|
||||
CheckInt128Case({12345, kHex, /*width = */ 0, "3039"});
|
||||
CheckInt128Case(
|
||||
{0x8000000000000000, kDec, /*width = */ 0, "9223372036854775808"});
|
||||
CheckInt128Case(
|
||||
{0x8000000000000000, kOct, /*width = */ 0, "1000000000000000000000"});
|
||||
CheckInt128Case(
|
||||
{0x8000000000000000, kHex, /*width = */ 0, "8000000000000000"});
|
||||
CheckInt128Case({std::numeric_limits<uint64_t>::max(), kDec,
|
||||
/*width = */ 0, "18446744073709551615"});
|
||||
CheckInt128Case({std::numeric_limits<uint64_t>::max(), kOct,
|
||||
/*width = */ 0, "1777777777777777777777"});
|
||||
CheckInt128Case({std::numeric_limits<uint64_t>::max(), kHex,
|
||||
/*width = */ 0, "ffffffffffffffff"});
|
||||
CheckInt128Case(
|
||||
{absl::MakeInt128(1, 0), kDec, /*width = */ 0, "18446744073709551616"});
|
||||
CheckInt128Case(
|
||||
{absl::MakeInt128(1, 0), kOct, /*width = */ 0, "2000000000000000000000"});
|
||||
CheckInt128Case(
|
||||
{absl::MakeInt128(1, 0), kHex, /*width = */ 0, "10000000000000000"});
|
||||
CheckInt128Case({absl::MakeInt128(std::numeric_limits<int64_t>::max(),
|
||||
std::numeric_limits<uint64_t>::max()),
|
||||
std::ios::dec, /*width = */ 0,
|
||||
"170141183460469231731687303715884105727"});
|
||||
CheckInt128Case({absl::MakeInt128(std::numeric_limits<int64_t>::max(),
|
||||
std::numeric_limits<uint64_t>::max()),
|
||||
std::ios::oct, /*width = */ 0,
|
||||
"1777777777777777777777777777777777777777777"});
|
||||
CheckInt128Case({absl::MakeInt128(std::numeric_limits<int64_t>::max(),
|
||||
std::numeric_limits<uint64_t>::max()),
|
||||
std::ios::hex, /*width = */ 0,
|
||||
"7fffffffffffffffffffffffffffffff"});
|
||||
CheckInt128Case({absl::MakeInt128(std::numeric_limits<int64_t>::min(), 0),
|
||||
std::ios::dec, /*width = */ 0,
|
||||
"-170141183460469231731687303715884105728"});
|
||||
CheckInt128Case({absl::MakeInt128(std::numeric_limits<int64_t>::min(), 0),
|
||||
std::ios::oct, /*width = */ 0,
|
||||
"2000000000000000000000000000000000000000000"});
|
||||
CheckInt128Case({absl::MakeInt128(std::numeric_limits<int64_t>::min(), 0),
|
||||
std::ios::hex, /*width = */ 0,
|
||||
"80000000000000000000000000000000"});
|
||||
CheckInt128Case({-1, std::ios::dec, /*width = */ 0, "-1"});
|
||||
CheckInt128Case({-1, std::ios::oct, /*width = */ 0,
|
||||
"3777777777777777777777777777777777777777777"});
|
||||
CheckInt128Case(
|
||||
{-1, std::ios::hex, /*width = */ 0, "ffffffffffffffffffffffffffffffff"});
|
||||
CheckInt128Case({-12345, std::ios::dec, /*width = */ 0, "-12345"});
|
||||
CheckInt128Case({-12345, std::ios::oct, /*width = */ 0,
|
||||
"3777777777777777777777777777777777777747707"});
|
||||
CheckInt128Case({-12345, std::ios::hex, /*width = */ 0,
|
||||
"ffffffffffffffffffffffffffffcfc7"});
|
||||
}
|
||||
|
||||
std::vector<Int128TestCase> GetInt128FormatCases();
|
||||
TEST(Int128, OStreamFormatTest) {
|
||||
for (const Int128TestCase& test_case : GetInt128FormatCases()) {
|
||||
CheckInt128Case(test_case);
|
||||
}
|
||||
}
|
||||
|
||||
std::vector<Int128TestCase> GetInt128FormatCases() {
|
||||
return {
|
||||
{0, std::ios_base::fmtflags(), /*width = */ 0, "0"},
|
||||
{0, std::ios_base::fmtflags(), /*width = */ 6, "_____0"},
|
||||
{0, kPos, /*width = */ 0, "+0"},
|
||||
{0, kPos, /*width = */ 6, "____+0"},
|
||||
{0, kBase, /*width = */ 0, "0"},
|
||||
{0, kBase, /*width = */ 6, "_____0"},
|
||||
{0, kBase | kPos, /*width = */ 0, "+0"},
|
||||
{0, kBase | kPos, /*width = */ 6, "____+0"},
|
||||
{0, kUpper, /*width = */ 0, "0"},
|
||||
{0, kUpper, /*width = */ 6, "_____0"},
|
||||
{0, kUpper | kPos, /*width = */ 0, "+0"},
|
||||
{0, kUpper | kPos, /*width = */ 6, "____+0"},
|
||||
{0, kUpper | kBase, /*width = */ 0, "0"},
|
||||
{0, kUpper | kBase, /*width = */ 6, "_____0"},
|
||||
{0, kUpper | kBase | kPos, /*width = */ 0, "+0"},
|
||||
{0, kUpper | kBase | kPos, /*width = */ 6, "____+0"},
|
||||
{0, kLeft, /*width = */ 0, "0"},
|
||||
{0, kLeft, /*width = */ 6, "0_____"},
|
||||
{0, kLeft | kPos, /*width = */ 0, "+0"},
|
||||
{0, kLeft | kPos, /*width = */ 6, "+0____"},
|
||||
{0, kLeft | kBase, /*width = */ 0, "0"},
|
||||
{0, kLeft | kBase, /*width = */ 6, "0_____"},
|
||||
{0, kLeft | kBase | kPos, /*width = */ 0, "+0"},
|
||||
{0, kLeft | kBase | kPos, /*width = */ 6, "+0____"},
|
||||
{0, kLeft | kUpper, /*width = */ 0, "0"},
|
||||
{0, kLeft | kUpper, /*width = */ 6, "0_____"},
|
||||
{0, kLeft | kUpper | kPos, /*width = */ 0, "+0"},
|
||||
{0, kLeft | kUpper | kPos, /*width = */ 6, "+0____"},
|
||||
{0, kLeft | kUpper | kBase, /*width = */ 0, "0"},
|
||||
{0, kLeft | kUpper | kBase, /*width = */ 6, "0_____"},
|
||||
{0, kLeft | kUpper | kBase | kPos, /*width = */ 0, "+0"},
|
||||
{0, kLeft | kUpper | kBase | kPos, /*width = */ 6, "+0____"},
|
||||
{0, kInt, /*width = */ 0, "0"},
|
||||
{0, kInt, /*width = */ 6, "_____0"},
|
||||
{0, kInt | kPos, /*width = */ 0, "+0"},
|
||||
{0, kInt | kPos, /*width = */ 6, "+____0"},
|
||||
{0, kInt | kBase, /*width = */ 0, "0"},
|
||||
{0, kInt | kBase, /*width = */ 6, "_____0"},
|
||||
{0, kInt | kBase | kPos, /*width = */ 0, "+0"},
|
||||
{0, kInt | kBase | kPos, /*width = */ 6, "+____0"},
|
||||
{0, kInt | kUpper, /*width = */ 0, "0"},
|
||||
{0, kInt | kUpper, /*width = */ 6, "_____0"},
|
||||
{0, kInt | kUpper | kPos, /*width = */ 0, "+0"},
|
||||
{0, kInt | kUpper | kPos, /*width = */ 6, "+____0"},
|
||||
{0, kInt | kUpper | kBase, /*width = */ 0, "0"},
|
||||
{0, kInt | kUpper | kBase, /*width = */ 6, "_____0"},
|
||||
{0, kInt | kUpper | kBase | kPos, /*width = */ 0, "+0"},
|
||||
{0, kInt | kUpper | kBase | kPos, /*width = */ 6, "+____0"},
|
||||
{0, kRight, /*width = */ 0, "0"},
|
||||
{0, kRight, /*width = */ 6, "_____0"},
|
||||
{0, kRight | kPos, /*width = */ 0, "+0"},
|
||||
{0, kRight | kPos, /*width = */ 6, "____+0"},
|
||||
{0, kRight | kBase, /*width = */ 0, "0"},
|
||||
{0, kRight | kBase, /*width = */ 6, "_____0"},
|
||||
{0, kRight | kBase | kPos, /*width = */ 0, "+0"},
|
||||
{0, kRight | kBase | kPos, /*width = */ 6, "____+0"},
|
||||
{0, kRight | kUpper, /*width = */ 0, "0"},
|
||||
{0, kRight | kUpper, /*width = */ 6, "_____0"},
|
||||
{0, kRight | kUpper | kPos, /*width = */ 0, "+0"},
|
||||
{0, kRight | kUpper | kPos, /*width = */ 6, "____+0"},
|
||||
{0, kRight | kUpper | kBase, /*width = */ 0, "0"},
|
||||
{0, kRight | kUpper | kBase, /*width = */ 6, "_____0"},
|
||||
{0, kRight | kUpper | kBase | kPos, /*width = */ 0, "+0"},
|
||||
{0, kRight | kUpper | kBase | kPos, /*width = */ 6, "____+0"},
|
||||
{0, kDec, /*width = */ 0, "0"},
|
||||
{0, kDec, /*width = */ 6, "_____0"},
|
||||
{0, kDec | kPos, /*width = */ 0, "+0"},
|
||||
{0, kDec | kPos, /*width = */ 6, "____+0"},
|
||||
{0, kDec | kBase, /*width = */ 0, "0"},
|
||||
{0, kDec | kBase, /*width = */ 6, "_____0"},
|
||||
{0, kDec | kBase | kPos, /*width = */ 0, "+0"},
|
||||
{0, kDec | kBase | kPos, /*width = */ 6, "____+0"},
|
||||
{0, kDec | kUpper, /*width = */ 0, "0"},
|
||||
{0, kDec | kUpper, /*width = */ 6, "_____0"},
|
||||
{0, kDec | kUpper | kPos, /*width = */ 0, "+0"},
|
||||
{0, kDec | kUpper | kPos, /*width = */ 6, "____+0"},
|
||||
{0, kDec | kUpper | kBase, /*width = */ 0, "0"},
|
||||
{0, kDec | kUpper | kBase, /*width = */ 6, "_____0"},
|
||||
{0, kDec | kUpper | kBase | kPos, /*width = */ 0, "+0"},
|
||||
{0, kDec | kUpper | kBase | kPos, /*width = */ 6, "____+0"},
|
||||
{0, kDec | kLeft, /*width = */ 0, "0"},
|
||||
{0, kDec | kLeft, /*width = */ 6, "0_____"},
|
||||
{0, kDec | kLeft | kPos, /*width = */ 0, "+0"},
|
||||
{0, kDec | kLeft | kPos, /*width = */ 6, "+0____"},
|
||||
{0, kDec | kLeft | kBase, /*width = */ 0, "0"},
|
||||
{0, kDec | kLeft | kBase, /*width = */ 6, "0_____"},
|
||||
{0, kDec | kLeft | kBase | kPos, /*width = */ 0, "+0"},
|
||||
{0, kDec | kLeft | kBase | kPos, /*width = */ 6, "+0____"},
|
||||
{0, kDec | kLeft | kUpper, /*width = */ 0, "0"},
|
||||
{0, kDec | kLeft | kUpper, /*width = */ 6, "0_____"},
|
||||
{0, kDec | kLeft | kUpper | kPos, /*width = */ 0, "+0"},
|
||||
{0, kDec | kLeft | kUpper | kPos, /*width = */ 6, "+0____"},
|
||||
{0, kDec | kLeft | kUpper | kBase, /*width = */ 0, "0"},
|
||||
{0, kDec | kLeft | kUpper | kBase, /*width = */ 6, "0_____"},
|
||||
{0, kDec | kLeft | kUpper | kBase | kPos, /*width = */ 0, "+0"},
|
||||
{0, kDec | kLeft | kUpper | kBase | kPos, /*width = */ 6, "+0____"},
|
||||
{0, kDec | kInt, /*width = */ 0, "0"},
|
||||
{0, kDec | kInt, /*width = */ 6, "_____0"},
|
||||
{0, kDec | kInt | kPos, /*width = */ 0, "+0"},
|
||||
{0, kDec | kInt | kPos, /*width = */ 6, "+____0"},
|
||||
{0, kDec | kInt | kBase, /*width = */ 0, "0"},
|
||||
{0, kDec | kInt | kBase, /*width = */ 6, "_____0"},
|
||||
{0, kDec | kInt | kBase | kPos, /*width = */ 0, "+0"},
|
||||
{0, kDec | kInt | kBase | kPos, /*width = */ 6, "+____0"},
|
||||
{0, kDec | kInt | kUpper, /*width = */ 0, "0"},
|
||||
{0, kDec | kInt | kUpper, /*width = */ 6, "_____0"},
|
||||
{0, kDec | kInt | kUpper | kPos, /*width = */ 0, "+0"},
|
||||
{0, kDec | kInt | kUpper | kPos, /*width = */ 6, "+____0"},
|
||||
{0, kDec | kInt | kUpper | kBase, /*width = */ 0, "0"},
|
||||
{0, kDec | kInt | kUpper | kBase, /*width = */ 6, "_____0"},
|
||||
{0, kDec | kInt | kUpper | kBase | kPos, /*width = */ 0, "+0"},
|
||||
{0, kDec | kInt | kUpper | kBase | kPos, /*width = */ 6, "+____0"},
|
||||
{0, kDec | kRight, /*width = */ 0, "0"},
|
||||
{0, kDec | kRight, /*width = */ 6, "_____0"},
|
||||
{0, kDec | kRight | kPos, /*width = */ 0, "+0"},
|
||||
{0, kDec | kRight | kPos, /*width = */ 6, "____+0"},
|
||||
{0, kDec | kRight | kBase, /*width = */ 0, "0"},
|
||||
{0, kDec | kRight | kBase, /*width = */ 6, "_____0"},
|
||||
{0, kDec | kRight | kBase | kPos, /*width = */ 0, "+0"},
|
||||
{0, kDec | kRight | kBase | kPos, /*width = */ 6, "____+0"},
|
||||
{0, kDec | kRight | kUpper, /*width = */ 0, "0"},
|
||||
{0, kDec | kRight | kUpper, /*width = */ 6, "_____0"},
|
||||
{0, kDec | kRight | kUpper | kPos, /*width = */ 0, "+0"},
|
||||
{0, kDec | kRight | kUpper | kPos, /*width = */ 6, "____+0"},
|
||||
{0, kDec | kRight | kUpper | kBase, /*width = */ 0, "0"},
|
||||
{0, kDec | kRight | kUpper | kBase, /*width = */ 6, "_____0"},
|
||||
{0, kDec | kRight | kUpper | kBase | kPos, /*width = */ 0, "+0"},
|
||||
{0, kDec | kRight | kUpper | kBase | kPos, /*width = */ 6, "____+0"},
|
||||
{0, kOct, /*width = */ 0, "0"},
|
||||
{0, kOct, /*width = */ 6, "_____0"},
|
||||
{0, kOct | kPos, /*width = */ 0, "0"},
|
||||
{0, kOct | kPos, /*width = */ 6, "_____0"},
|
||||
{0, kOct | kBase, /*width = */ 0, "0"},
|
||||
{0, kOct | kBase, /*width = */ 6, "_____0"},
|
||||
{0, kOct | kBase | kPos, /*width = */ 0, "0"},
|
||||
{0, kOct | kBase | kPos, /*width = */ 6, "_____0"},
|
||||
{0, kOct | kUpper, /*width = */ 0, "0"},
|
||||
{0, kOct | kUpper, /*width = */ 6, "_____0"},
|
||||
{0, kOct | kUpper | kPos, /*width = */ 0, "0"},
|
||||
{0, kOct | kUpper | kPos, /*width = */ 6, "_____0"},
|
||||
{0, kOct | kUpper | kBase, /*width = */ 0, "0"},
|
||||
{0, kOct | kUpper | kBase, /*width = */ 6, "_____0"},
|
||||
{0, kOct | kUpper | kBase | kPos, /*width = */ 0, "0"},
|
||||
{0, kOct | kUpper | kBase | kPos, /*width = */ 6, "_____0"},
|
||||
{0, kOct | kLeft, /*width = */ 0, "0"},
|
||||
{0, kOct | kLeft, /*width = */ 6, "0_____"},
|
||||
{0, kOct | kLeft | kPos, /*width = */ 0, "0"},
|
||||
{0, kOct | kLeft | kPos, /*width = */ 6, "0_____"},
|
||||
{0, kOct | kLeft | kBase, /*width = */ 0, "0"},
|
||||
{0, kOct | kLeft | kBase, /*width = */ 6, "0_____"},
|
||||
{0, kOct | kLeft | kBase | kPos, /*width = */ 0, "0"},
|
||||
{0, kOct | kLeft | kBase | kPos, /*width = */ 6, "0_____"},
|
||||
{0, kOct | kLeft | kUpper, /*width = */ 0, "0"},
|
||||
{0, kOct | kLeft | kUpper, /*width = */ 6, "0_____"},
|
||||
{0, kOct | kLeft | kUpper | kPos, /*width = */ 0, "0"},
|
||||
{0, kOct | kLeft | kUpper | kPos, /*width = */ 6, "0_____"},
|
||||
{0, kOct | kLeft | kUpper | kBase, /*width = */ 0, "0"},
|
||||
{0, kOct | kLeft | kUpper | kBase, /*width = */ 6, "0_____"},
|
||||
{0, kOct | kLeft | kUpper | kBase | kPos, /*width = */ 0, "0"},
|
||||
{0, kOct | kLeft | kUpper | kBase | kPos, /*width = */ 6, "0_____"},
|
||||
{0, kOct | kInt, /*width = */ 0, "0"},
|
||||
{0, kOct | kInt, /*width = */ 6, "_____0"},
|
||||
{0, kOct | kInt | kPos, /*width = */ 0, "0"},
|
||||
{0, kOct | kInt | kPos, /*width = */ 6, "_____0"},
|
||||
{0, kOct | kInt | kBase, /*width = */ 0, "0"},
|
||||
{0, kOct | kInt | kBase, /*width = */ 6, "_____0"},
|
||||
{0, kOct | kInt | kBase | kPos, /*width = */ 0, "0"},
|
||||
{0, kOct | kInt | kBase | kPos, /*width = */ 6, "_____0"},
|
||||
{0, kOct | kInt | kUpper, /*width = */ 0, "0"},
|
||||
{0, kOct | kInt | kUpper, /*width = */ 6, "_____0"},
|
||||
{0, kOct | kInt | kUpper | kPos, /*width = */ 0, "0"},
|
||||
{0, kOct | kInt | kUpper | kPos, /*width = */ 6, "_____0"},
|
||||
{0, kOct | kInt | kUpper | kBase, /*width = */ 0, "0"},
|
||||
{0, kOct | kInt | kUpper | kBase, /*width = */ 6, "_____0"},
|
||||
{0, kOct | kInt | kUpper | kBase | kPos, /*width = */ 0, "0"},
|
||||
{0, kOct | kInt | kUpper | kBase | kPos, /*width = */ 6, "_____0"},
|
||||
{0, kOct | kRight, /*width = */ 0, "0"},
|
||||
{0, kOct | kRight, /*width = */ 6, "_____0"},
|
||||
{0, kOct | kRight | kPos, /*width = */ 0, "0"},
|
||||
{0, kOct | kRight | kPos, /*width = */ 6, "_____0"},
|
||||
{0, kOct | kRight | kBase, /*width = */ 0, "0"},
|
||||
{0, kOct | kRight | kBase, /*width = */ 6, "_____0"},
|
||||
{0, kOct | kRight | kBase | kPos, /*width = */ 0, "0"},
|
||||
{0, kOct | kRight | kBase | kPos, /*width = */ 6, "_____0"},
|
||||
{0, kOct | kRight | kUpper, /*width = */ 0, "0"},
|
||||
{0, kOct | kRight | kUpper, /*width = */ 6, "_____0"},
|
||||
{0, kOct | kRight | kUpper | kPos, /*width = */ 0, "0"},
|
||||
{0, kOct | kRight | kUpper | kPos, /*width = */ 6, "_____0"},
|
||||
{0, kOct | kRight | kUpper | kBase, /*width = */ 0, "0"},
|
||||
{0, kOct | kRight | kUpper | kBase, /*width = */ 6, "_____0"},
|
||||
{0, kOct | kRight | kUpper | kBase | kPos, /*width = */ 0, "0"},
|
||||
{0, kOct | kRight | kUpper | kBase | kPos, /*width = */ 6, "_____0"},
|
||||
{0, kHex, /*width = */ 0, "0"},
|
||||
{0, kHex, /*width = */ 6, "_____0"},
|
||||
{0, kHex | kPos, /*width = */ 0, "0"},
|
||||
{0, kHex | kPos, /*width = */ 6, "_____0"},
|
||||
{0, kHex | kBase, /*width = */ 0, "0"},
|
||||
{0, kHex | kBase, /*width = */ 6, "_____0"},
|
||||
{0, kHex | kBase | kPos, /*width = */ 0, "0"},
|
||||
{0, kHex | kBase | kPos, /*width = */ 6, "_____0"},
|
||||
{0, kHex | kUpper, /*width = */ 0, "0"},
|
||||
{0, kHex | kUpper, /*width = */ 6, "_____0"},
|
||||
{0, kHex | kUpper | kPos, /*width = */ 0, "0"},
|
||||
{0, kHex | kUpper | kPos, /*width = */ 6, "_____0"},
|
||||
{0, kHex | kUpper | kBase, /*width = */ 0, "0"},
|
||||
{0, kHex | kUpper | kBase, /*width = */ 6, "_____0"},
|
||||
{0, kHex | kUpper | kBase | kPos, /*width = */ 0, "0"},
|
||||
{0, kHex | kUpper | kBase | kPos, /*width = */ 6, "_____0"},
|
||||
{0, kHex | kLeft, /*width = */ 0, "0"},
|
||||
{0, kHex | kLeft, /*width = */ 6, "0_____"},
|
||||
{0, kHex | kLeft | kPos, /*width = */ 0, "0"},
|
||||
{0, kHex | kLeft | kPos, /*width = */ 6, "0_____"},
|
||||
{0, kHex | kLeft | kBase, /*width = */ 0, "0"},
|
||||
{0, kHex | kLeft | kBase, /*width = */ 6, "0_____"},
|
||||
{0, kHex | kLeft | kBase | kPos, /*width = */ 0, "0"},
|
||||
{0, kHex | kLeft | kBase | kPos, /*width = */ 6, "0_____"},
|
||||
{0, kHex | kLeft | kUpper, /*width = */ 0, "0"},
|
||||
{0, kHex | kLeft | kUpper, /*width = */ 6, "0_____"},
|
||||
{0, kHex | kLeft | kUpper | kPos, /*width = */ 0, "0"},
|
||||
{0, kHex | kLeft | kUpper | kPos, /*width = */ 6, "0_____"},
|
||||
{0, kHex | kLeft | kUpper | kBase, /*width = */ 0, "0"},
|
||||
{0, kHex | kLeft | kUpper | kBase, /*width = */ 6, "0_____"},
|
||||
{0, kHex | kLeft | kUpper | kBase | kPos, /*width = */ 0, "0"},
|
||||
{0, kHex | kLeft | kUpper | kBase | kPos, /*width = */ 6, "0_____"},
|
||||
{0, kHex | kInt, /*width = */ 0, "0"},
|
||||
{0, kHex | kInt, /*width = */ 6, "_____0"},
|
||||
{0, kHex | kInt | kPos, /*width = */ 0, "0"},
|
||||
{0, kHex | kInt | kPos, /*width = */ 6, "_____0"},
|
||||
{0, kHex | kInt | kBase, /*width = */ 0, "0"},
|
||||
{0, kHex | kInt | kBase, /*width = */ 6, "_____0"},
|
||||
{0, kHex | kInt | kBase | kPos, /*width = */ 0, "0"},
|
||||
{0, kHex | kInt | kBase | kPos, /*width = */ 6, "_____0"},
|
||||
{0, kHex | kInt | kUpper, /*width = */ 0, "0"},
|
||||
{0, kHex | kInt | kUpper, /*width = */ 6, "_____0"},
|
||||
{0, kHex | kInt | kUpper | kPos, /*width = */ 0, "0"},
|
||||
{0, kHex | kInt | kUpper | kPos, /*width = */ 6, "_____0"},
|
||||
{0, kHex | kInt | kUpper | kBase, /*width = */ 0, "0"},
|
||||
{0, kHex | kInt | kUpper | kBase, /*width = */ 6, "_____0"},
|
||||
{0, kHex | kInt | kUpper | kBase | kPos, /*width = */ 0, "0"},
|
||||
{0, kHex | kInt | kUpper | kBase | kPos, /*width = */ 6, "_____0"},
|
||||
{0, kHex | kRight, /*width = */ 0, "0"},
|
||||
{0, kHex | kRight, /*width = */ 6, "_____0"},
|
||||
{0, kHex | kRight | kPos, /*width = */ 0, "0"},
|
||||
{0, kHex | kRight | kPos, /*width = */ 6, "_____0"},
|
||||
{0, kHex | kRight | kBase, /*width = */ 0, "0"},
|
||||
{0, kHex | kRight | kBase, /*width = */ 6, "_____0"},
|
||||
{0, kHex | kRight | kBase | kPos, /*width = */ 0, "0"},
|
||||
{0, kHex | kRight | kBase | kPos, /*width = */ 6, "_____0"},
|
||||
{0, kHex | kRight | kUpper, /*width = */ 0, "0"},
|
||||
{0, kHex | kRight | kUpper, /*width = */ 6, "_____0"},
|
||||
{0, kHex | kRight | kUpper | kPos, /*width = */ 0, "0"},
|
||||
{0, kHex | kRight | kUpper | kPos, /*width = */ 6, "_____0"},
|
||||
{0, kHex | kRight | kUpper | kBase, /*width = */ 0, "0"},
|
||||
{0, kHex | kRight | kUpper | kBase, /*width = */ 6, "_____0"},
|
||||
{0, kHex | kRight | kUpper | kBase | kPos, /*width = */ 0, "0"},
|
||||
{0, kHex | kRight | kUpper | kBase | kPos, /*width = */ 6, "_____0"},
|
||||
{42, std::ios_base::fmtflags(), /*width = */ 0, "42"},
|
||||
{42, std::ios_base::fmtflags(), /*width = */ 6, "____42"},
|
||||
{42, kPos, /*width = */ 0, "+42"},
|
||||
{42, kPos, /*width = */ 6, "___+42"},
|
||||
{42, kBase, /*width = */ 0, "42"},
|
||||
{42, kBase, /*width = */ 6, "____42"},
|
||||
{42, kBase | kPos, /*width = */ 0, "+42"},
|
||||
{42, kBase | kPos, /*width = */ 6, "___+42"},
|
||||
{42, kUpper, /*width = */ 0, "42"},
|
||||
{42, kUpper, /*width = */ 6, "____42"},
|
||||
{42, kUpper | kPos, /*width = */ 0, "+42"},
|
||||
{42, kUpper | kPos, /*width = */ 6, "___+42"},
|
||||
{42, kUpper | kBase, /*width = */ 0, "42"},
|
||||
{42, kUpper | kBase, /*width = */ 6, "____42"},
|
||||
{42, kUpper | kBase | kPos, /*width = */ 0, "+42"},
|
||||
{42, kUpper | kBase | kPos, /*width = */ 6, "___+42"},
|
||||
{42, kLeft, /*width = */ 0, "42"},
|
||||
{42, kLeft, /*width = */ 6, "42____"},
|
||||
{42, kLeft | kPos, /*width = */ 0, "+42"},
|
||||
{42, kLeft | kPos, /*width = */ 6, "+42___"},
|
||||
{42, kLeft | kBase, /*width = */ 0, "42"},
|
||||
{42, kLeft | kBase, /*width = */ 6, "42____"},
|
||||
{42, kLeft | kBase | kPos, /*width = */ 0, "+42"},
|
||||
{42, kLeft | kBase | kPos, /*width = */ 6, "+42___"},
|
||||
{42, kLeft | kUpper, /*width = */ 0, "42"},
|
||||
{42, kLeft | kUpper, /*width = */ 6, "42____"},
|
||||
{42, kLeft | kUpper | kPos, /*width = */ 0, "+42"},
|
||||
{42, kLeft | kUpper | kPos, /*width = */ 6, "+42___"},
|
||||
{42, kLeft | kUpper | kBase, /*width = */ 0, "42"},
|
||||
{42, kLeft | kUpper | kBase, /*width = */ 6, "42____"},
|
||||
{42, kLeft | kUpper | kBase | kPos, /*width = */ 0, "+42"},
|
||||
{42, kLeft | kUpper | kBase | kPos, /*width = */ 6, "+42___"},
|
||||
{42, kInt, /*width = */ 0, "42"},
|
||||
{42, kInt, /*width = */ 6, "____42"},
|
||||
{42, kInt | kPos, /*width = */ 0, "+42"},
|
||||
{42, kInt | kPos, /*width = */ 6, "+___42"},
|
||||
{42, kInt | kBase, /*width = */ 0, "42"},
|
||||
{42, kInt | kBase, /*width = */ 6, "____42"},
|
||||
{42, kInt | kBase | kPos, /*width = */ 0, "+42"},
|
||||
{42, kInt | kBase | kPos, /*width = */ 6, "+___42"},
|
||||
{42, kInt | kUpper, /*width = */ 0, "42"},
|
||||
{42, kInt | kUpper, /*width = */ 6, "____42"},
|
||||
{42, kInt | kUpper | kPos, /*width = */ 0, "+42"},
|
||||
{42, kInt | kUpper | kPos, /*width = */ 6, "+___42"},
|
||||
{42, kInt | kUpper | kBase, /*width = */ 0, "42"},
|
||||
{42, kInt | kUpper | kBase, /*width = */ 6, "____42"},
|
||||
{42, kInt | kUpper | kBase | kPos, /*width = */ 0, "+42"},
|
||||
{42, kInt | kUpper | kBase | kPos, /*width = */ 6, "+___42"},
|
||||
{42, kRight, /*width = */ 0, "42"},
|
||||
{42, kRight, /*width = */ 6, "____42"},
|
||||
{42, kRight | kPos, /*width = */ 0, "+42"},
|
||||
{42, kRight | kPos, /*width = */ 6, "___+42"},
|
||||
{42, kRight | kBase, /*width = */ 0, "42"},
|
||||
{42, kRight | kBase, /*width = */ 6, "____42"},
|
||||
{42, kRight | kBase | kPos, /*width = */ 0, "+42"},
|
||||
{42, kRight | kBase | kPos, /*width = */ 6, "___+42"},
|
||||
{42, kRight | kUpper, /*width = */ 0, "42"},
|
||||
{42, kRight | kUpper, /*width = */ 6, "____42"},
|
||||
{42, kRight | kUpper | kPos, /*width = */ 0, "+42"},
|
||||
{42, kRight | kUpper | kPos, /*width = */ 6, "___+42"},
|
||||
{42, kRight | kUpper | kBase, /*width = */ 0, "42"},
|
||||
{42, kRight | kUpper | kBase, /*width = */ 6, "____42"},
|
||||
{42, kRight | kUpper | kBase | kPos, /*width = */ 0, "+42"},
|
||||
{42, kRight | kUpper | kBase | kPos, /*width = */ 6, "___+42"},
|
||||
{42, kDec, /*width = */ 0, "42"},
|
||||
{42, kDec, /*width = */ 6, "____42"},
|
||||
{42, kDec | kPos, /*width = */ 0, "+42"},
|
||||
{42, kDec | kPos, /*width = */ 6, "___+42"},
|
||||
{42, kDec | kBase, /*width = */ 0, "42"},
|
||||
{42, kDec | kBase, /*width = */ 6, "____42"},
|
||||
{42, kDec | kBase | kPos, /*width = */ 0, "+42"},
|
||||
{42, kDec | kBase | kPos, /*width = */ 6, "___+42"},
|
||||
{42, kDec | kUpper, /*width = */ 0, "42"},
|
||||
{42, kDec | kUpper, /*width = */ 6, "____42"},
|
||||
{42, kDec | kUpper | kPos, /*width = */ 0, "+42"},
|
||||
{42, kDec | kUpper | kPos, /*width = */ 6, "___+42"},
|
||||
{42, kDec | kUpper | kBase, /*width = */ 0, "42"},
|
||||
{42, kDec | kUpper | kBase, /*width = */ 6, "____42"},
|
||||
{42, kDec | kUpper | kBase | kPos, /*width = */ 0, "+42"},
|
||||
{42, kDec | kUpper | kBase | kPos, /*width = */ 6, "___+42"},
|
||||
{42, kDec | kLeft, /*width = */ 0, "42"},
|
||||
{42, kDec | kLeft, /*width = */ 6, "42____"},
|
||||
{42, kDec | kLeft | kPos, /*width = */ 0, "+42"},
|
||||
{42, kDec | kLeft | kPos, /*width = */ 6, "+42___"},
|
||||
{42, kDec | kLeft | kBase, /*width = */ 0, "42"},
|
||||
{42, kDec | kLeft | kBase, /*width = */ 6, "42____"},
|
||||
{42, kDec | kLeft | kBase | kPos, /*width = */ 0, "+42"},
|
||||
{42, kDec | kLeft | kBase | kPos, /*width = */ 6, "+42___"},
|
||||
{42, kDec | kLeft | kUpper, /*width = */ 0, "42"},
|
||||
{42, kDec | kLeft | kUpper, /*width = */ 6, "42____"},
|
||||
{42, kDec | kLeft | kUpper | kPos, /*width = */ 0, "+42"},
|
||||
{42, kDec | kLeft | kUpper | kPos, /*width = */ 6, "+42___"},
|
||||
{42, kDec | kLeft | kUpper | kBase, /*width = */ 0, "42"},
|
||||
{42, kDec | kLeft | kUpper | kBase, /*width = */ 6, "42____"},
|
||||
{42, kDec | kLeft | kUpper | kBase | kPos, /*width = */ 0, "+42"},
|
||||
{42, kDec | kLeft | kUpper | kBase | kPos, /*width = */ 6, "+42___"},
|
||||
{42, kDec | kInt, /*width = */ 0, "42"},
|
||||
{42, kDec | kInt, /*width = */ 6, "____42"},
|
||||
{42, kDec | kInt | kPos, /*width = */ 0, "+42"},
|
||||
{42, kDec | kInt | kPos, /*width = */ 6, "+___42"},
|
||||
{42, kDec | kInt | kBase, /*width = */ 0, "42"},
|
||||
{42, kDec | kInt | kBase, /*width = */ 6, "____42"},
|
||||
{42, kDec | kInt | kBase | kPos, /*width = */ 0, "+42"},
|
||||
{42, kDec | kInt | kBase | kPos, /*width = */ 6, "+___42"},
|
||||
{42, kDec | kInt | kUpper, /*width = */ 0, "42"},
|
||||
{42, kDec | kInt | kUpper, /*width = */ 6, "____42"},
|
||||
{42, kDec | kInt | kUpper | kPos, /*width = */ 0, "+42"},
|
||||
{42, kDec | kInt | kUpper | kPos, /*width = */ 6, "+___42"},
|
||||
{42, kDec | kInt | kUpper | kBase, /*width = */ 0, "42"},
|
||||
{42, kDec | kInt | kUpper | kBase, /*width = */ 6, "____42"},
|
||||
{42, kDec | kInt | kUpper | kBase | kPos, /*width = */ 0, "+42"},
|
||||
{42, kDec | kInt | kUpper | kBase | kPos, /*width = */ 6, "+___42"},
|
||||
{42, kDec | kRight, /*width = */ 0, "42"},
|
||||
{42, kDec | kRight, /*width = */ 6, "____42"},
|
||||
{42, kDec | kRight | kPos, /*width = */ 0, "+42"},
|
||||
{42, kDec | kRight | kPos, /*width = */ 6, "___+42"},
|
||||
{42, kDec | kRight | kBase, /*width = */ 0, "42"},
|
||||
{42, kDec | kRight | kBase, /*width = */ 6, "____42"},
|
||||
{42, kDec | kRight | kBase | kPos, /*width = */ 0, "+42"},
|
||||
{42, kDec | kRight | kBase | kPos, /*width = */ 6, "___+42"},
|
||||
{42, kDec | kRight | kUpper, /*width = */ 0, "42"},
|
||||
{42, kDec | kRight | kUpper, /*width = */ 6, "____42"},
|
||||
{42, kDec | kRight | kUpper | kPos, /*width = */ 0, "+42"},
|
||||
{42, kDec | kRight | kUpper | kPos, /*width = */ 6, "___+42"},
|
||||
{42, kDec | kRight | kUpper | kBase, /*width = */ 0, "42"},
|
||||
{42, kDec | kRight | kUpper | kBase, /*width = */ 6, "____42"},
|
||||
{42, kDec | kRight | kUpper | kBase | kPos, /*width = */ 0, "+42"},
|
||||
{42, kDec | kRight | kUpper | kBase | kPos, /*width = */ 6, "___+42"},
|
||||
{42, kOct, /*width = */ 0, "52"},
|
||||
{42, kOct, /*width = */ 6, "____52"},
|
||||
{42, kOct | kPos, /*width = */ 0, "52"},
|
||||
{42, kOct | kPos, /*width = */ 6, "____52"},
|
||||
{42, kOct | kBase, /*width = */ 0, "052"},
|
||||
{42, kOct | kBase, /*width = */ 6, "___052"},
|
||||
{42, kOct | kBase | kPos, /*width = */ 0, "052"},
|
||||
{42, kOct | kBase | kPos, /*width = */ 6, "___052"},
|
||||
{42, kOct | kUpper, /*width = */ 0, "52"},
|
||||
{42, kOct | kUpper, /*width = */ 6, "____52"},
|
||||
{42, kOct | kUpper | kPos, /*width = */ 0, "52"},
|
||||
{42, kOct | kUpper | kPos, /*width = */ 6, "____52"},
|
||||
{42, kOct | kUpper | kBase, /*width = */ 0, "052"},
|
||||
{42, kOct | kUpper | kBase, /*width = */ 6, "___052"},
|
||||
{42, kOct | kUpper | kBase | kPos, /*width = */ 0, "052"},
|
||||
{42, kOct | kUpper | kBase | kPos, /*width = */ 6, "___052"},
|
||||
{42, kOct | kLeft, /*width = */ 0, "52"},
|
||||
{42, kOct | kLeft, /*width = */ 6, "52____"},
|
||||
{42, kOct | kLeft | kPos, /*width = */ 0, "52"},
|
||||
{42, kOct | kLeft | kPos, /*width = */ 6, "52____"},
|
||||
{42, kOct | kLeft | kBase, /*width = */ 0, "052"},
|
||||
{42, kOct | kLeft | kBase, /*width = */ 6, "052___"},
|
||||
{42, kOct | kLeft | kBase | kPos, /*width = */ 0, "052"},
|
||||
{42, kOct | kLeft | kBase | kPos, /*width = */ 6, "052___"},
|
||||
{42, kOct | kLeft | kUpper, /*width = */ 0, "52"},
|
||||
{42, kOct | kLeft | kUpper, /*width = */ 6, "52____"},
|
||||
{42, kOct | kLeft | kUpper | kPos, /*width = */ 0, "52"},
|
||||
{42, kOct | kLeft | kUpper | kPos, /*width = */ 6, "52____"},
|
||||
{42, kOct | kLeft | kUpper | kBase, /*width = */ 0, "052"},
|
||||
{42, kOct | kLeft | kUpper | kBase, /*width = */ 6, "052___"},
|
||||
{42, kOct | kLeft | kUpper | kBase | kPos, /*width = */ 0, "052"},
|
||||
{42, kOct | kLeft | kUpper | kBase | kPos, /*width = */ 6, "052___"},
|
||||
{42, kOct | kInt, /*width = */ 0, "52"},
|
||||
{42, kOct | kInt, /*width = */ 6, "____52"},
|
||||
{42, kOct | kInt | kPos, /*width = */ 0, "52"},
|
||||
{42, kOct | kInt | kPos, /*width = */ 6, "____52"},
|
||||
{42, kOct | kInt | kBase, /*width = */ 0, "052"},
|
||||
{42, kOct | kInt | kBase, /*width = */ 6, "___052"},
|
||||
{42, kOct | kInt | kBase | kPos, /*width = */ 0, "052"},
|
||||
{42, kOct | kInt | kBase | kPos, /*width = */ 6, "___052"},
|
||||
{42, kOct | kInt | kUpper, /*width = */ 0, "52"},
|
||||
{42, kOct | kInt | kUpper, /*width = */ 6, "____52"},
|
||||
{42, kOct | kInt | kUpper | kPos, /*width = */ 0, "52"},
|
||||
{42, kOct | kInt | kUpper | kPos, /*width = */ 6, "____52"},
|
||||
{42, kOct | kInt | kUpper | kBase, /*width = */ 0, "052"},
|
||||
{42, kOct | kInt | kUpper | kBase, /*width = */ 6, "___052"},
|
||||
{42, kOct | kInt | kUpper | kBase | kPos, /*width = */ 0, "052"},
|
||||
{42, kOct | kInt | kUpper | kBase | kPos, /*width = */ 6, "___052"},
|
||||
{42, kOct | kRight, /*width = */ 0, "52"},
|
||||
{42, kOct | kRight, /*width = */ 6, "____52"},
|
||||
{42, kOct | kRight | kPos, /*width = */ 0, "52"},
|
||||
{42, kOct | kRight | kPos, /*width = */ 6, "____52"},
|
||||
{42, kOct | kRight | kBase, /*width = */ 0, "052"},
|
||||
{42, kOct | kRight | kBase, /*width = */ 6, "___052"},
|
||||
{42, kOct | kRight | kBase | kPos, /*width = */ 0, "052"},
|
||||
{42, kOct | kRight | kBase | kPos, /*width = */ 6, "___052"},
|
||||
{42, kOct | kRight | kUpper, /*width = */ 0, "52"},
|
||||
{42, kOct | kRight | kUpper, /*width = */ 6, "____52"},
|
||||
{42, kOct | kRight | kUpper | kPos, /*width = */ 0, "52"},
|
||||
{42, kOct | kRight | kUpper | kPos, /*width = */ 6, "____52"},
|
||||
{42, kOct | kRight | kUpper | kBase, /*width = */ 0, "052"},
|
||||
{42, kOct | kRight | kUpper | kBase, /*width = */ 6, "___052"},
|
||||
{42, kOct | kRight | kUpper | kBase | kPos, /*width = */ 0, "052"},
|
||||
{42, kOct | kRight | kUpper | kBase | kPos, /*width = */ 6, "___052"},
|
||||
{42, kHex, /*width = */ 0, "2a"},
|
||||
{42, kHex, /*width = */ 6, "____2a"},
|
||||
{42, kHex | kPos, /*width = */ 0, "2a"},
|
||||
{42, kHex | kPos, /*width = */ 6, "____2a"},
|
||||
{42, kHex | kBase, /*width = */ 0, "0x2a"},
|
||||
{42, kHex | kBase, /*width = */ 6, "__0x2a"},
|
||||
{42, kHex | kBase | kPos, /*width = */ 0, "0x2a"},
|
||||
{42, kHex | kBase | kPos, /*width = */ 6, "__0x2a"},
|
||||
{42, kHex | kUpper, /*width = */ 0, "2A"},
|
||||
{42, kHex | kUpper, /*width = */ 6, "____2A"},
|
||||
{42, kHex | kUpper | kPos, /*width = */ 0, "2A"},
|
||||
{42, kHex | kUpper | kPos, /*width = */ 6, "____2A"},
|
||||
{42, kHex | kUpper | kBase, /*width = */ 0, "0X2A"},
|
||||
{42, kHex | kUpper | kBase, /*width = */ 6, "__0X2A"},
|
||||
{42, kHex | kUpper | kBase | kPos, /*width = */ 0, "0X2A"},
|
||||
{42, kHex | kUpper | kBase | kPos, /*width = */ 6, "__0X2A"},
|
||||
{42, kHex | kLeft, /*width = */ 0, "2a"},
|
||||
{42, kHex | kLeft, /*width = */ 6, "2a____"},
|
||||
{42, kHex | kLeft | kPos, /*width = */ 0, "2a"},
|
||||
{42, kHex | kLeft | kPos, /*width = */ 6, "2a____"},
|
||||
{42, kHex | kLeft | kBase, /*width = */ 0, "0x2a"},
|
||||
{42, kHex | kLeft | kBase, /*width = */ 6, "0x2a__"},
|
||||
{42, kHex | kLeft | kBase | kPos, /*width = */ 0, "0x2a"},
|
||||
{42, kHex | kLeft | kBase | kPos, /*width = */ 6, "0x2a__"},
|
||||
{42, kHex | kLeft | kUpper, /*width = */ 0, "2A"},
|
||||
{42, kHex | kLeft | kUpper, /*width = */ 6, "2A____"},
|
||||
{42, kHex | kLeft | kUpper | kPos, /*width = */ 0, "2A"},
|
||||
{42, kHex | kLeft | kUpper | kPos, /*width = */ 6, "2A____"},
|
||||
{42, kHex | kLeft | kUpper | kBase, /*width = */ 0, "0X2A"},
|
||||
{42, kHex | kLeft | kUpper | kBase, /*width = */ 6, "0X2A__"},
|
||||
{42, kHex | kLeft | kUpper | kBase | kPos, /*width = */ 0, "0X2A"},
|
||||
{42, kHex | kLeft | kUpper | kBase | kPos, /*width = */ 6, "0X2A__"},
|
||||
{42, kHex | kInt, /*width = */ 0, "2a"},
|
||||
{42, kHex | kInt, /*width = */ 6, "____2a"},
|
||||
{42, kHex | kInt | kPos, /*width = */ 0, "2a"},
|
||||
{42, kHex | kInt | kPos, /*width = */ 6, "____2a"},
|
||||
{42, kHex | kInt | kBase, /*width = */ 0, "0x2a"},
|
||||
{42, kHex | kInt | kBase, /*width = */ 6, "0x__2a"},
|
||||
{42, kHex | kInt | kBase | kPos, /*width = */ 0, "0x2a"},
|
||||
{42, kHex | kInt | kBase | kPos, /*width = */ 6, "0x__2a"},
|
||||
{42, kHex | kInt | kUpper, /*width = */ 0, "2A"},
|
||||
{42, kHex | kInt | kUpper, /*width = */ 6, "____2A"},
|
||||
{42, kHex | kInt | kUpper | kPos, /*width = */ 0, "2A"},
|
||||
{42, kHex | kInt | kUpper | kPos, /*width = */ 6, "____2A"},
|
||||
{42, kHex | kInt | kUpper | kBase, /*width = */ 0, "0X2A"},
|
||||
{42, kHex | kInt | kUpper | kBase, /*width = */ 6, "0X__2A"},
|
||||
{42, kHex | kInt | kUpper | kBase | kPos, /*width = */ 0, "0X2A"},
|
||||
{42, kHex | kInt | kUpper | kBase | kPos, /*width = */ 6, "0X__2A"},
|
||||
{42, kHex | kRight, /*width = */ 0, "2a"},
|
||||
{42, kHex | kRight, /*width = */ 6, "____2a"},
|
||||
{42, kHex | kRight | kPos, /*width = */ 0, "2a"},
|
||||
{42, kHex | kRight | kPos, /*width = */ 6, "____2a"},
|
||||
{42, kHex | kRight | kBase, /*width = */ 0, "0x2a"},
|
||||
{42, kHex | kRight | kBase, /*width = */ 6, "__0x2a"},
|
||||
{42, kHex | kRight | kBase | kPos, /*width = */ 0, "0x2a"},
|
||||
{42, kHex | kRight | kBase | kPos, /*width = */ 6, "__0x2a"},
|
||||
{42, kHex | kRight | kUpper, /*width = */ 0, "2A"},
|
||||
{42, kHex | kRight | kUpper, /*width = */ 6, "____2A"},
|
||||
{42, kHex | kRight | kUpper | kPos, /*width = */ 0, "2A"},
|
||||
{42, kHex | kRight | kUpper | kPos, /*width = */ 6, "____2A"},
|
||||
{42, kHex | kRight | kUpper | kBase, /*width = */ 0, "0X2A"},
|
||||
{42, kHex | kRight | kUpper | kBase, /*width = */ 6, "__0X2A"},
|
||||
{42, kHex | kRight | kUpper | kBase | kPos, /*width = */ 0, "0X2A"},
|
||||
{42, kHex | kRight | kUpper | kBase | kPos, /*width = */ 6, "__0X2A"},
|
||||
{-321, std::ios_base::fmtflags(), /*width = */ 0, "-321"},
|
||||
{-321, std::ios_base::fmtflags(), /*width = */ 6, "__-321"},
|
||||
{-321, kPos, /*width = */ 0, "-321"},
|
||||
{-321, kPos, /*width = */ 6, "__-321"},
|
||||
{-321, kBase, /*width = */ 0, "-321"},
|
||||
{-321, kBase, /*width = */ 6, "__-321"},
|
||||
{-321, kBase | kPos, /*width = */ 0, "-321"},
|
||||
{-321, kBase | kPos, /*width = */ 6, "__-321"},
|
||||
{-321, kUpper, /*width = */ 0, "-321"},
|
||||
{-321, kUpper, /*width = */ 6, "__-321"},
|
||||
{-321, kUpper | kPos, /*width = */ 0, "-321"},
|
||||
{-321, kUpper | kPos, /*width = */ 6, "__-321"},
|
||||
{-321, kUpper | kBase, /*width = */ 0, "-321"},
|
||||
{-321, kUpper | kBase, /*width = */ 6, "__-321"},
|
||||
{-321, kUpper | kBase | kPos, /*width = */ 0, "-321"},
|
||||
{-321, kUpper | kBase | kPos, /*width = */ 6, "__-321"},
|
||||
{-321, kLeft, /*width = */ 0, "-321"},
|
||||
{-321, kLeft, /*width = */ 6, "-321__"},
|
||||
{-321, kLeft | kPos, /*width = */ 0, "-321"},
|
||||
{-321, kLeft | kPos, /*width = */ 6, "-321__"},
|
||||
{-321, kLeft | kBase, /*width = */ 0, "-321"},
|
||||
{-321, kLeft | kBase, /*width = */ 6, "-321__"},
|
||||
{-321, kLeft | kBase | kPos, /*width = */ 0, "-321"},
|
||||
{-321, kLeft | kBase | kPos, /*width = */ 6, "-321__"},
|
||||
{-321, kLeft | kUpper, /*width = */ 0, "-321"},
|
||||
{-321, kLeft | kUpper, /*width = */ 6, "-321__"},
|
||||
{-321, kLeft | kUpper | kPos, /*width = */ 0, "-321"},
|
||||
{-321, kLeft | kUpper | kPos, /*width = */ 6, "-321__"},
|
||||
{-321, kLeft | kUpper | kBase, /*width = */ 0, "-321"},
|
||||
{-321, kLeft | kUpper | kBase, /*width = */ 6, "-321__"},
|
||||
{-321, kLeft | kUpper | kBase | kPos, /*width = */ 0, "-321"},
|
||||
{-321, kLeft | kUpper | kBase | kPos, /*width = */ 6, "-321__"},
|
||||
{-321, kInt, /*width = */ 0, "-321"},
|
||||
{-321, kInt, /*width = */ 6, "-__321"},
|
||||
{-321, kInt | kPos, /*width = */ 0, "-321"},
|
||||
{-321, kInt | kPos, /*width = */ 6, "-__321"},
|
||||
{-321, kInt | kBase, /*width = */ 0, "-321"},
|
||||
{-321, kInt | kBase, /*width = */ 6, "-__321"},
|
||||
{-321, kInt | kBase | kPos, /*width = */ 0, "-321"},
|
||||
{-321, kInt | kBase | kPos, /*width = */ 6, "-__321"},
|
||||
{-321, kInt | kUpper, /*width = */ 0, "-321"},
|
||||
{-321, kInt | kUpper, /*width = */ 6, "-__321"},
|
||||
{-321, kInt | kUpper | kPos, /*width = */ 0, "-321"},
|
||||
{-321, kInt | kUpper | kPos, /*width = */ 6, "-__321"},
|
||||
{-321, kInt | kUpper | kBase, /*width = */ 0, "-321"},
|
||||
{-321, kInt | kUpper | kBase, /*width = */ 6, "-__321"},
|
||||
{-321, kInt | kUpper | kBase | kPos, /*width = */ 0, "-321"},
|
||||
{-321, kInt | kUpper | kBase | kPos, /*width = */ 6, "-__321"},
|
||||
{-321, kRight, /*width = */ 0, "-321"},
|
||||
{-321, kRight, /*width = */ 6, "__-321"},
|
||||
{-321, kRight | kPos, /*width = */ 0, "-321"},
|
||||
{-321, kRight | kPos, /*width = */ 6, "__-321"},
|
||||
{-321, kRight | kBase, /*width = */ 0, "-321"},
|
||||
{-321, kRight | kBase, /*width = */ 6, "__-321"},
|
||||
{-321, kRight | kBase | kPos, /*width = */ 0, "-321"},
|
||||
{-321, kRight | kBase | kPos, /*width = */ 6, "__-321"},
|
||||
{-321, kRight | kUpper, /*width = */ 0, "-321"},
|
||||
{-321, kRight | kUpper, /*width = */ 6, "__-321"},
|
||||
{-321, kRight | kUpper | kPos, /*width = */ 0, "-321"},
|
||||
{-321, kRight | kUpper | kPos, /*width = */ 6, "__-321"},
|
||||
{-321, kRight | kUpper | kBase, /*width = */ 0, "-321"},
|
||||
{-321, kRight | kUpper | kBase, /*width = */ 6, "__-321"},
|
||||
{-321, kRight | kUpper | kBase | kPos, /*width = */ 0, "-321"},
|
||||
{-321, kRight | kUpper | kBase | kPos, /*width = */ 6, "__-321"},
|
||||
{-321, kDec, /*width = */ 0, "-321"},
|
||||
{-321, kDec, /*width = */ 6, "__-321"},
|
||||
{-321, kDec | kPos, /*width = */ 0, "-321"},
|
||||
{-321, kDec | kPos, /*width = */ 6, "__-321"},
|
||||
{-321, kDec | kBase, /*width = */ 0, "-321"},
|
||||
{-321, kDec | kBase, /*width = */ 6, "__-321"},
|
||||
{-321, kDec | kBase | kPos, /*width = */ 0, "-321"},
|
||||
{-321, kDec | kBase | kPos, /*width = */ 6, "__-321"},
|
||||
{-321, kDec | kUpper, /*width = */ 0, "-321"},
|
||||
{-321, kDec | kUpper, /*width = */ 6, "__-321"},
|
||||
{-321, kDec | kUpper | kPos, /*width = */ 0, "-321"},
|
||||
{-321, kDec | kUpper | kPos, /*width = */ 6, "__-321"},
|
||||
{-321, kDec | kUpper | kBase, /*width = */ 0, "-321"},
|
||||
{-321, kDec | kUpper | kBase, /*width = */ 6, "__-321"},
|
||||
{-321, kDec | kUpper | kBase | kPos, /*width = */ 0, "-321"},
|
||||
{-321, kDec | kUpper | kBase | kPos, /*width = */ 6, "__-321"},
|
||||
{-321, kDec | kLeft, /*width = */ 0, "-321"},
|
||||
{-321, kDec | kLeft, /*width = */ 6, "-321__"},
|
||||
{-321, kDec | kLeft | kPos, /*width = */ 0, "-321"},
|
||||
{-321, kDec | kLeft | kPos, /*width = */ 6, "-321__"},
|
||||
{-321, kDec | kLeft | kBase, /*width = */ 0, "-321"},
|
||||
{-321, kDec | kLeft | kBase, /*width = */ 6, "-321__"},
|
||||
{-321, kDec | kLeft | kBase | kPos, /*width = */ 0, "-321"},
|
||||
{-321, kDec | kLeft | kBase | kPos, /*width = */ 6, "-321__"},
|
||||
{-321, kDec | kLeft | kUpper, /*width = */ 0, "-321"},
|
||||
{-321, kDec | kLeft | kUpper, /*width = */ 6, "-321__"},
|
||||
{-321, kDec | kLeft | kUpper | kPos, /*width = */ 0, "-321"},
|
||||
{-321, kDec | kLeft | kUpper | kPos, /*width = */ 6, "-321__"},
|
||||
{-321, kDec | kLeft | kUpper | kBase, /*width = */ 0, "-321"},
|
||||
{-321, kDec | kLeft | kUpper | kBase, /*width = */ 6, "-321__"},
|
||||
{-321, kDec | kLeft | kUpper | kBase | kPos, /*width = */ 0, "-321"},
|
||||
{-321, kDec | kLeft | kUpper | kBase | kPos, /*width = */ 6, "-321__"},
|
||||
{-321, kDec | kInt, /*width = */ 0, "-321"},
|
||||
{-321, kDec | kInt, /*width = */ 6, "-__321"},
|
||||
{-321, kDec | kInt | kPos, /*width = */ 0, "-321"},
|
||||
{-321, kDec | kInt | kPos, /*width = */ 6, "-__321"},
|
||||
{-321, kDec | kInt | kBase, /*width = */ 0, "-321"},
|
||||
{-321, kDec | kInt | kBase, /*width = */ 6, "-__321"},
|
||||
{-321, kDec | kInt | kBase | kPos, /*width = */ 0, "-321"},
|
||||
{-321, kDec | kInt | kBase | kPos, /*width = */ 6, "-__321"},
|
||||
{-321, kDec | kInt | kUpper, /*width = */ 0, "-321"},
|
||||
{-321, kDec | kInt | kUpper, /*width = */ 6, "-__321"},
|
||||
{-321, kDec | kInt | kUpper | kPos, /*width = */ 0, "-321"},
|
||||
{-321, kDec | kInt | kUpper | kPos, /*width = */ 6, "-__321"},
|
||||
{-321, kDec | kInt | kUpper | kBase, /*width = */ 0, "-321"},
|
||||
{-321, kDec | kInt | kUpper | kBase, /*width = */ 6, "-__321"},
|
||||
{-321, kDec | kInt | kUpper | kBase | kPos, /*width = */ 0, "-321"},
|
||||
{-321, kDec | kInt | kUpper | kBase | kPos, /*width = */ 6, "-__321"},
|
||||
{-321, kDec | kRight, /*width = */ 0, "-321"},
|
||||
{-321, kDec | kRight, /*width = */ 6, "__-321"},
|
||||
{-321, kDec | kRight | kPos, /*width = */ 0, "-321"},
|
||||
{-321, kDec | kRight | kPos, /*width = */ 6, "__-321"},
|
||||
{-321, kDec | kRight | kBase, /*width = */ 0, "-321"},
|
||||
{-321, kDec | kRight | kBase, /*width = */ 6, "__-321"},
|
||||
{-321, kDec | kRight | kBase | kPos, /*width = */ 0, "-321"},
|
||||
{-321, kDec | kRight | kBase | kPos, /*width = */ 6, "__-321"},
|
||||
{-321, kDec | kRight | kUpper, /*width = */ 0, "-321"},
|
||||
{-321, kDec | kRight | kUpper, /*width = */ 6, "__-321"},
|
||||
{-321, kDec | kRight | kUpper | kPos, /*width = */ 0, "-321"},
|
||||
{-321, kDec | kRight | kUpper | kPos, /*width = */ 6, "__-321"},
|
||||
{-321, kDec | kRight | kUpper | kBase, /*width = */ 0, "-321"},
|
||||
{-321, kDec | kRight | kUpper | kBase, /*width = */ 6, "__-321"},
|
||||
{-321, kDec | kRight | kUpper | kBase | kPos, /*width = */ 0, "-321"},
|
||||
{-321, kDec | kRight | kUpper | kBase | kPos, /*width = */ 6, "__-321"}};
|
||||
}
|
||||
|
||||
std::vector<Uint128TestCase> GetUint128FormatCases() {
|
||||
return {
|
||||
{0, std::ios_base::fmtflags(), /*width = */ 0, "0"},
|
||||
|
|
|
|||
|
|
@ -479,4 +479,747 @@ TEST(Uint128, Hash) {
|
|||
}));
|
||||
}
|
||||
|
||||
|
||||
TEST(Int128Uint128, ConversionTest) {
|
||||
absl::int128 nonnegative_signed_values[] = {
|
||||
0,
|
||||
1,
|
||||
0xffeeddccbbaa9988,
|
||||
absl::MakeInt128(0x7766554433221100, 0),
|
||||
absl::MakeInt128(0x1234567890abcdef, 0xfedcba0987654321),
|
||||
absl::Int128Max()};
|
||||
for (absl::int128 value : nonnegative_signed_values) {
|
||||
EXPECT_EQ(value, absl::int128(absl::uint128(value)));
|
||||
|
||||
absl::uint128 assigned_value;
|
||||
assigned_value = value;
|
||||
EXPECT_EQ(value, absl::int128(assigned_value));
|
||||
}
|
||||
|
||||
absl::int128 negative_values[] = {
|
||||
-1, -0x1234567890abcdef,
|
||||
absl::MakeInt128(-0x5544332211ffeedd, 0),
|
||||
-absl::MakeInt128(0x76543210fedcba98, 0xabcdef0123456789)};
|
||||
for (absl::int128 value : negative_values) {
|
||||
EXPECT_EQ(absl::uint128(-value), -absl::uint128(value));
|
||||
|
||||
absl::uint128 assigned_value;
|
||||
assigned_value = value;
|
||||
EXPECT_EQ(absl::uint128(-value), -assigned_value);
|
||||
}
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
class Int128IntegerTraitsTest : public ::testing::Test {};
|
||||
|
||||
TYPED_TEST_SUITE(Int128IntegerTraitsTest, IntegerTypes);
|
||||
|
||||
TYPED_TEST(Int128IntegerTraitsTest, ConstructAssignTest) {
|
||||
static_assert(std::is_constructible<absl::int128, TypeParam>::value,
|
||||
"absl::int128 must be constructible from TypeParam");
|
||||
static_assert(std::is_assignable<absl::int128&, TypeParam>::value,
|
||||
"absl::int128 must be assignable from TypeParam");
|
||||
static_assert(!std::is_assignable<TypeParam&, absl::int128>::value,
|
||||
"TypeParam must not be assignable from absl::int128");
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
class Int128FloatTraitsTest : public ::testing::Test {};
|
||||
|
||||
TYPED_TEST_SUITE(Int128FloatTraitsTest, FloatingPointTypes);
|
||||
|
||||
TYPED_TEST(Int128FloatTraitsTest, ConstructAssignTest) {
|
||||
static_assert(std::is_constructible<absl::int128, TypeParam>::value,
|
||||
"absl::int128 must be constructible from TypeParam");
|
||||
static_assert(!std::is_assignable<absl::int128&, TypeParam>::value,
|
||||
"absl::int128 must not be assignable from TypeParam");
|
||||
static_assert(!std::is_assignable<TypeParam&, absl::int128>::value,
|
||||
"TypeParam must not be assignable from absl::int128");
|
||||
}
|
||||
|
||||
#ifdef ABSL_HAVE_INTRINSIC_INT128
|
||||
// These type traits done separately as TYPED_TEST requires typeinfo, and not
|
||||
// all platforms have this for __int128 even though they define the type.
|
||||
TEST(Int128, IntrinsicTypeTraitsTest) {
|
||||
static_assert(std::is_constructible<absl::int128, __int128>::value,
|
||||
"absl::int128 must be constructible from __int128");
|
||||
static_assert(std::is_assignable<absl::int128&, __int128>::value,
|
||||
"absl::int128 must be assignable from __int128");
|
||||
static_assert(!std::is_assignable<__int128&, absl::int128>::value,
|
||||
"__int128 must not be assignable from absl::int128");
|
||||
|
||||
static_assert(std::is_constructible<absl::int128, unsigned __int128>::value,
|
||||
"absl::int128 must be constructible from unsigned __int128");
|
||||
static_assert(!std::is_assignable<absl::int128&, unsigned __int128>::value,
|
||||
"absl::int128 must be assignable from unsigned __int128");
|
||||
static_assert(!std::is_assignable<unsigned __int128&, absl::int128>::value,
|
||||
"unsigned __int128 must not be assignable from absl::int128");
|
||||
}
|
||||
#endif // ABSL_HAVE_INTRINSIC_INT128
|
||||
|
||||
TEST(Int128, TrivialTraitsTest) {
|
||||
static_assert(absl::is_trivially_default_constructible<absl::int128>::value,
|
||||
"");
|
||||
static_assert(absl::is_trivially_copy_constructible<absl::int128>::value, "");
|
||||
static_assert(absl::is_trivially_copy_assignable<absl::int128>::value, "");
|
||||
static_assert(std::is_trivially_destructible<absl::int128>::value, "");
|
||||
}
|
||||
|
||||
TEST(Int128, BoolConversionTest) {
|
||||
EXPECT_FALSE(absl::int128(0));
|
||||
for (int i = 0; i < 64; ++i) {
|
||||
EXPECT_TRUE(absl::MakeInt128(0, uint64_t{1} << i));
|
||||
}
|
||||
for (int i = 0; i < 63; ++i) {
|
||||
EXPECT_TRUE(absl::MakeInt128(int64_t{1} << i, 0));
|
||||
}
|
||||
EXPECT_TRUE(absl::Int128Min());
|
||||
|
||||
EXPECT_EQ(absl::int128(1), absl::int128(true));
|
||||
EXPECT_EQ(absl::int128(0), absl::int128(false));
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
class Int128IntegerConversionTest : public ::testing::Test {};
|
||||
|
||||
TYPED_TEST_SUITE(Int128IntegerConversionTest, IntegerTypes);
|
||||
|
||||
TYPED_TEST(Int128IntegerConversionTest, RoundTripTest) {
|
||||
EXPECT_EQ(TypeParam{0}, static_cast<TypeParam>(absl::int128(0)));
|
||||
EXPECT_EQ(std::numeric_limits<TypeParam>::min(),
|
||||
static_cast<TypeParam>(
|
||||
absl::int128(std::numeric_limits<TypeParam>::min())));
|
||||
EXPECT_EQ(std::numeric_limits<TypeParam>::max(),
|
||||
static_cast<TypeParam>(
|
||||
absl::int128(std::numeric_limits<TypeParam>::max())));
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
class Int128FloatConversionTest : public ::testing::Test {};
|
||||
|
||||
TYPED_TEST_SUITE(Int128FloatConversionTest, FloatingPointTypes);
|
||||
|
||||
TYPED_TEST(Int128FloatConversionTest, ConstructAndCastTest) {
|
||||
// Conversions where the floating point values should be exactly the same.
|
||||
// 0x9f5b is a randomly chosen small value.
|
||||
for (int i = 0; i < 110; ++i) { // 110 = 126 - #bits in 0x9f5b
|
||||
SCOPED_TRACE(::testing::Message() << "i = " << i);
|
||||
|
||||
TypeParam float_value = std::ldexp(static_cast<TypeParam>(0x9f5b), i);
|
||||
absl::int128 int_value = absl::int128(0x9f5b) << i;
|
||||
|
||||
EXPECT_EQ(float_value, static_cast<TypeParam>(int_value));
|
||||
EXPECT_EQ(-float_value, static_cast<TypeParam>(-int_value));
|
||||
EXPECT_EQ(int_value, absl::int128(float_value));
|
||||
EXPECT_EQ(-int_value, absl::int128(-float_value));
|
||||
}
|
||||
|
||||
// Round trip conversions with a small sample of randomly generated uint64_t
|
||||
// values (less than int64_t max so that value * 2^64 fits into int128).
|
||||
uint64_t values[] = {0x6d4492c24fb86199, 0x26ead65e4cb359b5,
|
||||
0x2c43407433ba3fd1, 0x3b574ec668df6b55,
|
||||
0x1c750e55a29f4f0f};
|
||||
for (uint64_t value : values) {
|
||||
for (int i = 0; i <= 64; ++i) {
|
||||
SCOPED_TRACE(::testing::Message()
|
||||
<< "value = " << value << "; i = " << i);
|
||||
|
||||
TypeParam fvalue = std::ldexp(static_cast<TypeParam>(value), i);
|
||||
EXPECT_DOUBLE_EQ(fvalue, static_cast<TypeParam>(absl::int128(fvalue)));
|
||||
EXPECT_DOUBLE_EQ(-fvalue, static_cast<TypeParam>(-absl::int128(fvalue)));
|
||||
EXPECT_DOUBLE_EQ(-fvalue, static_cast<TypeParam>(absl::int128(-fvalue)));
|
||||
EXPECT_DOUBLE_EQ(fvalue, static_cast<TypeParam>(-absl::int128(-fvalue)));
|
||||
}
|
||||
}
|
||||
|
||||
// Round trip conversions with a small sample of random large positive values.
|
||||
absl::int128 large_values[] = {
|
||||
absl::MakeInt128(0x5b0640d96c7b3d9f, 0xb7a7189e51d18622),
|
||||
absl::MakeInt128(0x34bed042c6f65270, 0x73b236570669a089),
|
||||
absl::MakeInt128(0x43deba9e6da12724, 0xf7f0f83da686797d),
|
||||
absl::MakeInt128(0x71e8d383be4e5589, 0x75c3f96fb00752b6)};
|
||||
for (absl::int128 value : large_values) {
|
||||
// Make value have as many significant bits as can be represented by
|
||||
// the mantissa, also making sure the highest and lowest bit in the range
|
||||
// are set.
|
||||
value >>= (127 - std::numeric_limits<TypeParam>::digits);
|
||||
value |= absl::int128(1) << (std::numeric_limits<TypeParam>::digits - 1);
|
||||
value |= 1;
|
||||
for (int i = 0; i < 127 - std::numeric_limits<TypeParam>::digits; ++i) {
|
||||
absl::int128 int_value = value << i;
|
||||
EXPECT_EQ(int_value,
|
||||
static_cast<absl::int128>(static_cast<TypeParam>(int_value)));
|
||||
EXPECT_EQ(-int_value,
|
||||
static_cast<absl::int128>(static_cast<TypeParam>(-int_value)));
|
||||
}
|
||||
}
|
||||
|
||||
// Small sample of checks that rounding is toward zero
|
||||
EXPECT_EQ(0, absl::int128(TypeParam(0.1)));
|
||||
EXPECT_EQ(17, absl::int128(TypeParam(17.8)));
|
||||
EXPECT_EQ(0, absl::int128(TypeParam(-0.8)));
|
||||
EXPECT_EQ(-53, absl::int128(TypeParam(-53.1)));
|
||||
EXPECT_EQ(0, absl::int128(TypeParam(0.5)));
|
||||
EXPECT_EQ(0, absl::int128(TypeParam(-0.5)));
|
||||
TypeParam just_lt_one = std::nexttoward(TypeParam(1), TypeParam(0));
|
||||
EXPECT_EQ(0, absl::int128(just_lt_one));
|
||||
TypeParam just_gt_minus_one = std::nexttoward(TypeParam(-1), TypeParam(0));
|
||||
EXPECT_EQ(0, absl::int128(just_gt_minus_one));
|
||||
|
||||
// Check limits
|
||||
EXPECT_DOUBLE_EQ(std::ldexp(static_cast<TypeParam>(1), 127),
|
||||
static_cast<TypeParam>(absl::Int128Max()));
|
||||
EXPECT_DOUBLE_EQ(-std::ldexp(static_cast<TypeParam>(1), 127),
|
||||
static_cast<TypeParam>(absl::Int128Min()));
|
||||
}
|
||||
|
||||
TEST(Int128, FactoryTest) {
|
||||
EXPECT_EQ(absl::int128(-1), absl::MakeInt128(-1, -1));
|
||||
EXPECT_EQ(absl::int128(-31), absl::MakeInt128(-1, -31));
|
||||
EXPECT_EQ(absl::int128(std::numeric_limits<int64_t>::min()),
|
||||
absl::MakeInt128(-1, std::numeric_limits<int64_t>::min()));
|
||||
EXPECT_EQ(absl::int128(0), absl::MakeInt128(0, 0));
|
||||
EXPECT_EQ(absl::int128(1), absl::MakeInt128(0, 1));
|
||||
EXPECT_EQ(absl::int128(std::numeric_limits<int64_t>::max()),
|
||||
absl::MakeInt128(0, std::numeric_limits<int64_t>::max()));
|
||||
}
|
||||
|
||||
TEST(Int128, HighLowTest) {
|
||||
struct HighLowPair {
|
||||
int64_t high;
|
||||
uint64_t low;
|
||||
};
|
||||
HighLowPair values[]{{0, 0}, {0, 1}, {1, 0}, {123, 456}, {-654, 321}};
|
||||
for (const HighLowPair& pair : values) {
|
||||
absl::int128 value = absl::MakeInt128(pair.high, pair.low);
|
||||
EXPECT_EQ(pair.low, absl::Int128Low64(value));
|
||||
EXPECT_EQ(pair.high, absl::Int128High64(value));
|
||||
}
|
||||
}
|
||||
|
||||
TEST(Int128, LimitsTest) {
|
||||
EXPECT_EQ(absl::MakeInt128(0x7fffffffffffffff, 0xffffffffffffffff),
|
||||
absl::Int128Max());
|
||||
EXPECT_EQ(absl::Int128Max(), ~absl::Int128Min());
|
||||
}
|
||||
|
||||
#if defined(ABSL_HAVE_INTRINSIC_INT128)
|
||||
TEST(Int128, IntrinsicConversionTest) {
|
||||
__int128 intrinsic =
|
||||
(static_cast<__int128>(0x3a5b76c209de76f6) << 64) + 0x1f25e1d63a2b46c5;
|
||||
absl::int128 custom =
|
||||
absl::MakeInt128(0x3a5b76c209de76f6, 0x1f25e1d63a2b46c5);
|
||||
|
||||
EXPECT_EQ(custom, absl::int128(intrinsic));
|
||||
EXPECT_EQ(intrinsic, static_cast<__int128>(custom));
|
||||
}
|
||||
#endif // ABSL_HAVE_INTRINSIC_INT128
|
||||
|
||||
TEST(Int128, ConstexprTest) {
|
||||
constexpr absl::int128 zero = absl::int128();
|
||||
constexpr absl::int128 one = 1;
|
||||
constexpr absl::int128 minus_two = -2;
|
||||
constexpr absl::int128 min = absl::Int128Min();
|
||||
constexpr absl::int128 max = absl::Int128Max();
|
||||
EXPECT_EQ(zero, absl::int128(0));
|
||||
EXPECT_EQ(one, absl::int128(1));
|
||||
EXPECT_EQ(minus_two, absl::MakeInt128(-1, -2));
|
||||
EXPECT_GT(max, one);
|
||||
EXPECT_LT(min, minus_two);
|
||||
}
|
||||
|
||||
TEST(Int128, ComparisonTest) {
|
||||
struct TestCase {
|
||||
absl::int128 smaller;
|
||||
absl::int128 larger;
|
||||
};
|
||||
TestCase cases[] = {
|
||||
{absl::int128(0), absl::int128(123)},
|
||||
{absl::MakeInt128(-12, 34), absl::MakeInt128(12, 34)},
|
||||
{absl::MakeInt128(1, 1000), absl::MakeInt128(1000, 1)},
|
||||
{absl::MakeInt128(-1000, 1000), absl::MakeInt128(-1, 1)},
|
||||
};
|
||||
for (const TestCase& pair : cases) {
|
||||
SCOPED_TRACE(::testing::Message() << "pair.smaller = " << pair.smaller
|
||||
<< "; pair.larger = " << pair.larger);
|
||||
|
||||
EXPECT_TRUE(pair.smaller == pair.smaller); // NOLINT(readability/check)
|
||||
EXPECT_TRUE(pair.larger == pair.larger); // NOLINT(readability/check)
|
||||
EXPECT_FALSE(pair.smaller == pair.larger); // NOLINT(readability/check)
|
||||
|
||||
EXPECT_TRUE(pair.smaller != pair.larger); // NOLINT(readability/check)
|
||||
EXPECT_FALSE(pair.smaller != pair.smaller); // NOLINT(readability/check)
|
||||
EXPECT_FALSE(pair.larger != pair.larger); // NOLINT(readability/check)
|
||||
|
||||
EXPECT_TRUE(pair.smaller < pair.larger); // NOLINT(readability/check)
|
||||
EXPECT_FALSE(pair.larger < pair.smaller); // NOLINT(readability/check)
|
||||
|
||||
EXPECT_TRUE(pair.larger > pair.smaller); // NOLINT(readability/check)
|
||||
EXPECT_FALSE(pair.smaller > pair.larger); // NOLINT(readability/check)
|
||||
|
||||
EXPECT_TRUE(pair.smaller <= pair.larger); // NOLINT(readability/check)
|
||||
EXPECT_FALSE(pair.larger <= pair.smaller); // NOLINT(readability/check)
|
||||
EXPECT_TRUE(pair.smaller <= pair.smaller); // NOLINT(readability/check)
|
||||
EXPECT_TRUE(pair.larger <= pair.larger); // NOLINT(readability/check)
|
||||
|
||||
EXPECT_TRUE(pair.larger >= pair.smaller); // NOLINT(readability/check)
|
||||
EXPECT_FALSE(pair.smaller >= pair.larger); // NOLINT(readability/check)
|
||||
EXPECT_TRUE(pair.smaller >= pair.smaller); // NOLINT(readability/check)
|
||||
EXPECT_TRUE(pair.larger >= pair.larger); // NOLINT(readability/check)
|
||||
}
|
||||
}
|
||||
|
||||
TEST(Int128, UnaryNegationTest) {
|
||||
int64_t values64[] = {0, 1, 12345, 0x4000000000000000,
|
||||
std::numeric_limits<int64_t>::max()};
|
||||
for (int64_t value : values64) {
|
||||
SCOPED_TRACE(::testing::Message() << "value = " << value);
|
||||
|
||||
EXPECT_EQ(absl::int128(-value), -absl::int128(value));
|
||||
EXPECT_EQ(absl::int128(value), -absl::int128(-value));
|
||||
EXPECT_EQ(absl::MakeInt128(-value, 0), -absl::MakeInt128(value, 0));
|
||||
EXPECT_EQ(absl::MakeInt128(value, 0), -absl::MakeInt128(-value, 0));
|
||||
}
|
||||
}
|
||||
|
||||
TEST(Int128, LogicalNotTest) {
|
||||
EXPECT_TRUE(!absl::int128(0));
|
||||
for (int i = 0; i < 64; ++i) {
|
||||
EXPECT_FALSE(!absl::MakeInt128(0, uint64_t{1} << i));
|
||||
}
|
||||
for (int i = 0; i < 63; ++i) {
|
||||
EXPECT_FALSE(!absl::MakeInt128(int64_t{1} << i, 0));
|
||||
}
|
||||
}
|
||||
|
||||
TEST(Int128, AdditionSubtractionTest) {
|
||||
// 64 bit pairs that will not cause overflow / underflow. These test negative
|
||||
// carry; positive carry must be checked separately.
|
||||
std::pair<int64_t, int64_t> cases[]{
|
||||
{0, 0}, // 0, 0
|
||||
{0, 2945781290834}, // 0, +
|
||||
{1908357619234, 0}, // +, 0
|
||||
{0, -1204895918245}, // 0, -
|
||||
{-2957928523560, 0}, // -, 0
|
||||
{89023982312461, 98346012567134}, // +, +
|
||||
{-63454234568239, -23456235230773}, // -, -
|
||||
{98263457263502, -21428561935925}, // +, -
|
||||
{-88235237438467, 15923659234573}, // -, +
|
||||
};
|
||||
for (const auto& pair : cases) {
|
||||
SCOPED_TRACE(::testing::Message()
|
||||
<< "pair = {" << pair.first << ", " << pair.second << '}');
|
||||
|
||||
EXPECT_EQ(absl::int128(pair.first + pair.second),
|
||||
absl::int128(pair.first) + absl::int128(pair.second));
|
||||
EXPECT_EQ(absl::int128(pair.second + pair.first),
|
||||
absl::int128(pair.second) += absl::int128(pair.first));
|
||||
|
||||
EXPECT_EQ(absl::int128(pair.first - pair.second),
|
||||
absl::int128(pair.first) - absl::int128(pair.second));
|
||||
EXPECT_EQ(absl::int128(pair.second - pair.first),
|
||||
absl::int128(pair.second) -= absl::int128(pair.first));
|
||||
|
||||
EXPECT_EQ(
|
||||
absl::MakeInt128(pair.second + pair.first, 0),
|
||||
absl::MakeInt128(pair.second, 0) + absl::MakeInt128(pair.first, 0));
|
||||
EXPECT_EQ(
|
||||
absl::MakeInt128(pair.first + pair.second, 0),
|
||||
absl::MakeInt128(pair.first, 0) += absl::MakeInt128(pair.second, 0));
|
||||
|
||||
EXPECT_EQ(
|
||||
absl::MakeInt128(pair.second - pair.first, 0),
|
||||
absl::MakeInt128(pair.second, 0) - absl::MakeInt128(pair.first, 0));
|
||||
EXPECT_EQ(
|
||||
absl::MakeInt128(pair.first - pair.second, 0),
|
||||
absl::MakeInt128(pair.first, 0) -= absl::MakeInt128(pair.second, 0));
|
||||
}
|
||||
|
||||
// check positive carry
|
||||
EXPECT_EQ(absl::MakeInt128(31, 0),
|
||||
absl::MakeInt128(20, 1) +
|
||||
absl::MakeInt128(10, std::numeric_limits<uint64_t>::max()));
|
||||
}
|
||||
|
||||
TEST(Int128, IncrementDecrementTest) {
|
||||
absl::int128 value = 0;
|
||||
EXPECT_EQ(0, value++);
|
||||
EXPECT_EQ(1, value);
|
||||
EXPECT_EQ(1, value--);
|
||||
EXPECT_EQ(0, value);
|
||||
EXPECT_EQ(-1, --value);
|
||||
EXPECT_EQ(-1, value);
|
||||
EXPECT_EQ(0, ++value);
|
||||
EXPECT_EQ(0, value);
|
||||
}
|
||||
|
||||
TEST(Int128, MultiplicationTest) {
|
||||
// 1 bit x 1 bit, and negative combinations
|
||||
for (int i = 0; i < 64; ++i) {
|
||||
for (int j = 0; j < 127 - i; ++j) {
|
||||
SCOPED_TRACE(::testing::Message() << "i = " << i << "; j = " << j);
|
||||
absl::int128 a = absl::int128(1) << i;
|
||||
absl::int128 b = absl::int128(1) << j;
|
||||
absl::int128 c = absl::int128(1) << (i + j);
|
||||
|
||||
EXPECT_EQ(c, a * b);
|
||||
EXPECT_EQ(-c, -a * b);
|
||||
EXPECT_EQ(-c, a * -b);
|
||||
EXPECT_EQ(c, -a * -b);
|
||||
|
||||
EXPECT_EQ(c, absl::int128(a) *= b);
|
||||
EXPECT_EQ(-c, absl::int128(-a) *= b);
|
||||
EXPECT_EQ(-c, absl::int128(a) *= -b);
|
||||
EXPECT_EQ(c, absl::int128(-a) *= -b);
|
||||
}
|
||||
}
|
||||
|
||||
// Pairs of random values that will not overflow signed 64-bit multiplication
|
||||
std::pair<int64_t, int64_t> small_values[] = {
|
||||
{0x5e61, 0xf29f79ca14b4}, // +, +
|
||||
{0x3e033b, -0x612c0ee549}, // +, -
|
||||
{-0x052ce7e8, 0x7c728f0f}, // -, +
|
||||
{-0x3af7054626, -0xfb1e1d}, // -, -
|
||||
};
|
||||
for (const std::pair<int64_t, int64_t>& pair : small_values) {
|
||||
SCOPED_TRACE(::testing::Message()
|
||||
<< "pair = {" << pair.first << ", " << pair.second << '}');
|
||||
|
||||
EXPECT_EQ(absl::int128(pair.first * pair.second),
|
||||
absl::int128(pair.first) * absl::int128(pair.second));
|
||||
EXPECT_EQ(absl::int128(pair.first * pair.second),
|
||||
absl::int128(pair.first) *= absl::int128(pair.second));
|
||||
|
||||
EXPECT_EQ(absl::MakeInt128(pair.first * pair.second, 0),
|
||||
absl::MakeInt128(pair.first, 0) * absl::int128(pair.second));
|
||||
EXPECT_EQ(absl::MakeInt128(pair.first * pair.second, 0),
|
||||
absl::MakeInt128(pair.first, 0) *= absl::int128(pair.second));
|
||||
}
|
||||
|
||||
// Pairs of positive random values that will not overflow 64-bit
|
||||
// multiplication and can be left shifted by 32 without overflow
|
||||
std::pair<int64_t, int64_t> small_values2[] = {
|
||||
{0x1bb0a110, 0x31487671},
|
||||
{0x4792784e, 0x28add7d7},
|
||||
{0x7b66553a, 0x11dff8ef},
|
||||
};
|
||||
for (const std::pair<int64_t, int64_t>& pair : small_values2) {
|
||||
SCOPED_TRACE(::testing::Message()
|
||||
<< "pair = {" << pair.first << ", " << pair.second << '}');
|
||||
|
||||
absl::int128 a = absl::int128(pair.first << 32);
|
||||
absl::int128 b = absl::int128(pair.second << 32);
|
||||
absl::int128 c = absl::MakeInt128(pair.first * pair.second, 0);
|
||||
|
||||
EXPECT_EQ(c, a * b);
|
||||
EXPECT_EQ(-c, -a * b);
|
||||
EXPECT_EQ(-c, a * -b);
|
||||
EXPECT_EQ(c, -a * -b);
|
||||
|
||||
EXPECT_EQ(c, absl::int128(a) *= b);
|
||||
EXPECT_EQ(-c, absl::int128(-a) *= b);
|
||||
EXPECT_EQ(-c, absl::int128(a) *= -b);
|
||||
EXPECT_EQ(c, absl::int128(-a) *= -b);
|
||||
}
|
||||
|
||||
// check 0, 1, and -1 behavior with large values
|
||||
absl::int128 large_values[] = {
|
||||
{absl::MakeInt128(0xd66f061af02d0408, 0x727d2846cb475b53)},
|
||||
{absl::MakeInt128(0x27b8d5ed6104452d, 0x03f8a33b0ee1df4f)},
|
||||
{-absl::MakeInt128(0x621b6626b9e8d042, 0x27311ac99df00938)},
|
||||
{-absl::MakeInt128(0x34e0656f1e95fb60, 0x4281cfd731257a47)},
|
||||
};
|
||||
for (absl::int128 value : large_values) {
|
||||
EXPECT_EQ(0, 0 * value);
|
||||
EXPECT_EQ(0, value * 0);
|
||||
EXPECT_EQ(0, absl::int128(0) *= value);
|
||||
EXPECT_EQ(0, value *= 0);
|
||||
|
||||
EXPECT_EQ(value, 1 * value);
|
||||
EXPECT_EQ(value, value * 1);
|
||||
EXPECT_EQ(value, absl::int128(1) *= value);
|
||||
EXPECT_EQ(value, value *= 1);
|
||||
|
||||
EXPECT_EQ(-value, -1 * value);
|
||||
EXPECT_EQ(-value, value * -1);
|
||||
EXPECT_EQ(-value, absl::int128(-1) *= value);
|
||||
EXPECT_EQ(-value, value *= -1);
|
||||
}
|
||||
|
||||
// Manually calculated random large value cases
|
||||
EXPECT_EQ(absl::MakeInt128(0xcd0efd3442219bb, 0xde47c05bcd9df6e1),
|
||||
absl::MakeInt128(0x7c6448, 0x3bc4285c47a9d253) * 0x1a6037537b);
|
||||
EXPECT_EQ(-absl::MakeInt128(0x1f8f149850b1e5e6, 0x1e50d6b52d272c3e),
|
||||
-absl::MakeInt128(0x23, 0x2e68a513ca1b8859) * 0xe5a434cd14866e);
|
||||
EXPECT_EQ(-absl::MakeInt128(0x55cae732029d1fce, 0xca6474b6423263e4),
|
||||
0xa9b98a8ddf66bc * -absl::MakeInt128(0x81, 0x672e58231e2469d7));
|
||||
EXPECT_EQ(absl::MakeInt128(0x19c8b7620b507dc4, 0xfec042b71a5f29a4),
|
||||
-0x3e39341147 * -absl::MakeInt128(0x6a14b2, 0x5ed34cca42327b3c));
|
||||
|
||||
EXPECT_EQ(absl::MakeInt128(0xcd0efd3442219bb, 0xde47c05bcd9df6e1),
|
||||
absl::MakeInt128(0x7c6448, 0x3bc4285c47a9d253) *= 0x1a6037537b);
|
||||
EXPECT_EQ(-absl::MakeInt128(0x1f8f149850b1e5e6, 0x1e50d6b52d272c3e),
|
||||
-absl::MakeInt128(0x23, 0x2e68a513ca1b8859) *= 0xe5a434cd14866e);
|
||||
EXPECT_EQ(-absl::MakeInt128(0x55cae732029d1fce, 0xca6474b6423263e4),
|
||||
absl::int128(0xa9b98a8ddf66bc) *=
|
||||
-absl::MakeInt128(0x81, 0x672e58231e2469d7));
|
||||
EXPECT_EQ(absl::MakeInt128(0x19c8b7620b507dc4, 0xfec042b71a5f29a4),
|
||||
absl::int128(-0x3e39341147) *=
|
||||
-absl::MakeInt128(0x6a14b2, 0x5ed34cca42327b3c));
|
||||
}
|
||||
|
||||
TEST(Int128, DivisionAndModuloTest) {
|
||||
// Check against 64 bit division and modulo operators with a sample of
|
||||
// randomly generated pairs.
|
||||
std::pair<int64_t, int64_t> small_pairs[] = {
|
||||
{0x15f2a64138, 0x67da05}, {0x5e56d194af43045f, 0xcf1543fb99},
|
||||
{0x15e61ed052036a, -0xc8e6}, {0x88125a341e85, -0xd23fb77683},
|
||||
{-0xc06e20, 0x5a}, {-0x4f100219aea3e85d, 0xdcc56cb4efe993},
|
||||
{-0x168d629105, -0xa7}, {-0x7b44e92f03ab2375, -0x6516},
|
||||
};
|
||||
for (const std::pair<int64_t, int64_t>& pair : small_pairs) {
|
||||
SCOPED_TRACE(::testing::Message()
|
||||
<< "pair = {" << pair.first << ", " << pair.second << '}');
|
||||
|
||||
absl::int128 dividend = pair.first;
|
||||
absl::int128 divisor = pair.second;
|
||||
int64_t quotient = pair.first / pair.second;
|
||||
int64_t remainder = pair.first % pair.second;
|
||||
|
||||
EXPECT_EQ(quotient, dividend / divisor);
|
||||
EXPECT_EQ(quotient, absl::int128(dividend) /= divisor);
|
||||
EXPECT_EQ(remainder, dividend % divisor);
|
||||
EXPECT_EQ(remainder, absl::int128(dividend) %= divisor);
|
||||
}
|
||||
|
||||
// Test behavior with 0, 1, and -1 with a sample of randomly generated large
|
||||
// values.
|
||||
absl::int128 values[] = {
|
||||
absl::MakeInt128(0x63d26ee688a962b2, 0x9e1411abda5c1d70),
|
||||
absl::MakeInt128(0x152f385159d6f986, 0xbf8d48ef63da395d),
|
||||
-absl::MakeInt128(0x3098d7567030038c, 0x14e7a8a098dc2164),
|
||||
-absl::MakeInt128(0x49a037aca35c809f, 0xa6a87525480ef330),
|
||||
};
|
||||
for (absl::int128 value : values) {
|
||||
SCOPED_TRACE(::testing::Message() << "value = " << value);
|
||||
|
||||
EXPECT_EQ(0, 0 / value);
|
||||
EXPECT_EQ(0, absl::int128(0) /= value);
|
||||
EXPECT_EQ(0, 0 % value);
|
||||
EXPECT_EQ(0, absl::int128(0) %= value);
|
||||
|
||||
EXPECT_EQ(value, value / 1);
|
||||
EXPECT_EQ(value, absl::int128(value) /= 1);
|
||||
EXPECT_EQ(0, value % 1);
|
||||
EXPECT_EQ(0, absl::int128(value) %= 1);
|
||||
|
||||
EXPECT_EQ(-value, value / -1);
|
||||
EXPECT_EQ(-value, absl::int128(value) /= -1);
|
||||
EXPECT_EQ(0, value % -1);
|
||||
EXPECT_EQ(0, absl::int128(value) %= -1);
|
||||
}
|
||||
|
||||
// Min and max values
|
||||
EXPECT_EQ(0, absl::Int128Max() / absl::Int128Min());
|
||||
EXPECT_EQ(absl::Int128Max(), absl::Int128Max() % absl::Int128Min());
|
||||
EXPECT_EQ(-1, absl::Int128Min() / absl::Int128Max());
|
||||
EXPECT_EQ(-1, absl::Int128Min() % absl::Int128Max());
|
||||
|
||||
// Power of two division and modulo of random large dividends
|
||||
absl::int128 positive_values[] = {
|
||||
absl::MakeInt128(0x21e1a1cc69574620, 0xe7ac447fab2fc869),
|
||||
absl::MakeInt128(0x32c2ff3ab89e66e8, 0x03379a613fd1ce74),
|
||||
absl::MakeInt128(0x6f32ca786184dcaf, 0x046f9c9ecb3a9ce1),
|
||||
absl::MakeInt128(0x1aeb469dd990e0ee, 0xda2740f243cd37eb),
|
||||
};
|
||||
for (absl::int128 value : positive_values) {
|
||||
for (int i = 0; i < 127; ++i) {
|
||||
SCOPED_TRACE(::testing::Message()
|
||||
<< "value = " << value << "; i = " << i);
|
||||
absl::int128 power_of_two = absl::int128(1) << i;
|
||||
|
||||
EXPECT_EQ(value >> i, value / power_of_two);
|
||||
EXPECT_EQ(value >> i, absl::int128(value) /= power_of_two);
|
||||
EXPECT_EQ(value & (power_of_two - 1), value % power_of_two);
|
||||
EXPECT_EQ(value & (power_of_two - 1),
|
||||
absl::int128(value) %= power_of_two);
|
||||
}
|
||||
}
|
||||
|
||||
// Manually calculated cases with random large dividends
|
||||
struct DivisionModCase {
|
||||
absl::int128 dividend;
|
||||
absl::int128 divisor;
|
||||
absl::int128 quotient;
|
||||
absl::int128 remainder;
|
||||
};
|
||||
DivisionModCase manual_cases[] = {
|
||||
{absl::MakeInt128(0x6ada48d489007966, 0x3c9c5c98150d5d69),
|
||||
absl::MakeInt128(0x8bc308fb, 0x8cb9cc9a3b803344), 0xc3b87e08,
|
||||
absl::MakeInt128(0x1b7db5e1, 0xd9eca34b7af04b49)},
|
||||
{absl::MakeInt128(0xd6946511b5b, 0x4886c5c96546bf5f),
|
||||
-absl::MakeInt128(0x263b, 0xfd516279efcfe2dc), -0x59cbabf0,
|
||||
absl::MakeInt128(0x622, 0xf462909155651d1f)},
|
||||
{-absl::MakeInt128(0x33db734f9e8d1399, 0x8447ac92482bca4d), 0x37495078240,
|
||||
-absl::MakeInt128(0xf01f1, 0xbc0368bf9a77eae8), -0x21a508f404d},
|
||||
{-absl::MakeInt128(0x13f837b409a07e7d, 0x7fc8e248a7d73560), -0x1b9f,
|
||||
absl::MakeInt128(0xb9157556d724, 0xb14f635714d7563e), -0x1ade},
|
||||
};
|
||||
for (const DivisionModCase test_case : manual_cases) {
|
||||
EXPECT_EQ(test_case.quotient, test_case.dividend / test_case.divisor);
|
||||
EXPECT_EQ(test_case.quotient,
|
||||
absl::int128(test_case.dividend) /= test_case.divisor);
|
||||
EXPECT_EQ(test_case.remainder, test_case.dividend % test_case.divisor);
|
||||
EXPECT_EQ(test_case.remainder,
|
||||
absl::int128(test_case.dividend) %= test_case.divisor);
|
||||
}
|
||||
}
|
||||
|
||||
TEST(Int128, BitwiseLogicTest) {
|
||||
EXPECT_EQ(absl::int128(-1), ~absl::int128(0));
|
||||
|
||||
absl::int128 values[]{
|
||||
0, -1, 0xde400bee05c3ff6b, absl::MakeInt128(0x7f32178dd81d634a, 0),
|
||||
absl::MakeInt128(0xaf539057055613a9, 0x7d104d7d946c2e4d)};
|
||||
for (absl::int128 value : values) {
|
||||
EXPECT_EQ(value, ~~value);
|
||||
|
||||
EXPECT_EQ(value, value | value);
|
||||
EXPECT_EQ(value, value & value);
|
||||
EXPECT_EQ(0, value ^ value);
|
||||
|
||||
EXPECT_EQ(value, absl::int128(value) |= value);
|
||||
EXPECT_EQ(value, absl::int128(value) &= value);
|
||||
EXPECT_EQ(0, absl::int128(value) ^= value);
|
||||
|
||||
EXPECT_EQ(value, value | 0);
|
||||
EXPECT_EQ(0, value & 0);
|
||||
EXPECT_EQ(value, value ^ 0);
|
||||
|
||||
EXPECT_EQ(absl::int128(-1), value | absl::int128(-1));
|
||||
EXPECT_EQ(value, value & absl::int128(-1));
|
||||
EXPECT_EQ(~value, value ^ absl::int128(-1));
|
||||
}
|
||||
|
||||
// small sample of randomly generated int64_t's
|
||||
std::pair<int64_t, int64_t> pairs64[]{
|
||||
{0x7f86797f5e991af4, 0x1ee30494fb007c97},
|
||||
{0x0b278282bacf01af, 0x58780e0a57a49e86},
|
||||
{0x059f266ccb93a666, 0x3d5b731bae9286f5},
|
||||
{0x63c0c4820f12108c, 0x58166713c12e1c3a},
|
||||
{0x381488bb2ed2a66e, 0x2220a3eb76a3698c},
|
||||
{0x2a0a0dfb81e06f21, 0x4b60585927f5523c},
|
||||
{0x555b1c3a03698537, 0x25478cd19d8e53cb},
|
||||
{0x4750f6f27d779225, 0x16397553c6ff05fc},
|
||||
};
|
||||
for (const std::pair<int64_t, int64_t>& pair : pairs64) {
|
||||
SCOPED_TRACE(::testing::Message()
|
||||
<< "pair = {" << pair.first << ", " << pair.second << '}');
|
||||
|
||||
EXPECT_EQ(absl::MakeInt128(~pair.first, ~pair.second),
|
||||
~absl::MakeInt128(pair.first, pair.second));
|
||||
|
||||
EXPECT_EQ(absl::int128(pair.first & pair.second),
|
||||
absl::int128(pair.first) & absl::int128(pair.second));
|
||||
EXPECT_EQ(absl::int128(pair.first | pair.second),
|
||||
absl::int128(pair.first) | absl::int128(pair.second));
|
||||
EXPECT_EQ(absl::int128(pair.first ^ pair.second),
|
||||
absl::int128(pair.first) ^ absl::int128(pair.second));
|
||||
|
||||
EXPECT_EQ(absl::int128(pair.first & pair.second),
|
||||
absl::int128(pair.first) &= absl::int128(pair.second));
|
||||
EXPECT_EQ(absl::int128(pair.first | pair.second),
|
||||
absl::int128(pair.first) |= absl::int128(pair.second));
|
||||
EXPECT_EQ(absl::int128(pair.first ^ pair.second),
|
||||
absl::int128(pair.first) ^= absl::int128(pair.second));
|
||||
|
||||
EXPECT_EQ(
|
||||
absl::MakeInt128(pair.first & pair.second, 0),
|
||||
absl::MakeInt128(pair.first, 0) & absl::MakeInt128(pair.second, 0));
|
||||
EXPECT_EQ(
|
||||
absl::MakeInt128(pair.first | pair.second, 0),
|
||||
absl::MakeInt128(pair.first, 0) | absl::MakeInt128(pair.second, 0));
|
||||
EXPECT_EQ(
|
||||
absl::MakeInt128(pair.first ^ pair.second, 0),
|
||||
absl::MakeInt128(pair.first, 0) ^ absl::MakeInt128(pair.second, 0));
|
||||
|
||||
EXPECT_EQ(
|
||||
absl::MakeInt128(pair.first & pair.second, 0),
|
||||
absl::MakeInt128(pair.first, 0) &= absl::MakeInt128(pair.second, 0));
|
||||
EXPECT_EQ(
|
||||
absl::MakeInt128(pair.first | pair.second, 0),
|
||||
absl::MakeInt128(pair.first, 0) |= absl::MakeInt128(pair.second, 0));
|
||||
EXPECT_EQ(
|
||||
absl::MakeInt128(pair.first ^ pair.second, 0),
|
||||
absl::MakeInt128(pair.first, 0) ^= absl::MakeInt128(pair.second, 0));
|
||||
}
|
||||
}
|
||||
|
||||
TEST(Int128, BitwiseShiftTest) {
|
||||
for (int i = 0; i < 64; ++i) {
|
||||
for (int j = 0; j <= i; ++j) {
|
||||
// Left shift from j-th bit to i-th bit.
|
||||
SCOPED_TRACE(::testing::Message() << "i = " << i << "; j = " << j);
|
||||
EXPECT_EQ(uint64_t{1} << i, absl::int128(uint64_t{1} << j) << (i - j));
|
||||
EXPECT_EQ(uint64_t{1} << i, absl::int128(uint64_t{1} << j) <<= (i - j));
|
||||
}
|
||||
}
|
||||
for (int i = 0; i < 63; ++i) {
|
||||
for (int j = 0; j < 64; ++j) {
|
||||
// Left shift from j-th bit to (i + 64)-th bit.
|
||||
SCOPED_TRACE(::testing::Message() << "i = " << i << "; j = " << j);
|
||||
EXPECT_EQ(absl::MakeInt128(uint64_t{1} << i, 0),
|
||||
absl::int128(uint64_t{1} << j) << (i + 64 - j));
|
||||
EXPECT_EQ(absl::MakeInt128(uint64_t{1} << i, 0),
|
||||
absl::int128(uint64_t{1} << j) <<= (i + 64 - j));
|
||||
}
|
||||
for (int j = 0; j <= i; ++j) {
|
||||
// Left shift from (j + 64)-th bit to (i + 64)-th bit.
|
||||
SCOPED_TRACE(::testing::Message() << "i = " << i << "; j = " << j);
|
||||
EXPECT_EQ(absl::MakeInt128(uint64_t{1} << i, 0),
|
||||
absl::MakeInt128(uint64_t{1} << j, 0) << (i - j));
|
||||
EXPECT_EQ(absl::MakeInt128(uint64_t{1} << i, 0),
|
||||
absl::MakeInt128(uint64_t{1} << j, 0) <<= (i - j));
|
||||
}
|
||||
}
|
||||
|
||||
for (int i = 0; i < 64; ++i) {
|
||||
for (int j = i; j < 64; ++j) {
|
||||
// Right shift from j-th bit to i-th bit.
|
||||
SCOPED_TRACE(::testing::Message() << "i = " << i << "; j = " << j);
|
||||
EXPECT_EQ(uint64_t{1} << i, absl::int128(uint64_t{1} << j) >> (j - i));
|
||||
EXPECT_EQ(uint64_t{1} << i, absl::int128(uint64_t{1} << j) >>= (j - i));
|
||||
}
|
||||
for (int j = 0; j < 63; ++j) {
|
||||
// Right shift from (j + 64)-th bit to i-th bit.
|
||||
SCOPED_TRACE(::testing::Message() << "i = " << i << "; j = " << j);
|
||||
EXPECT_EQ(uint64_t{1} << i,
|
||||
absl::MakeInt128(uint64_t{1} << j, 0) >> (j + 64 - i));
|
||||
EXPECT_EQ(uint64_t{1} << i,
|
||||
absl::MakeInt128(uint64_t{1} << j, 0) >>= (j + 64 - i));
|
||||
}
|
||||
}
|
||||
for (int i = 0; i < 63; ++i) {
|
||||
for (int j = i; j < 63; ++j) {
|
||||
// Right shift from (j + 64)-th bit to (i + 64)-th bit.
|
||||
SCOPED_TRACE(::testing::Message() << "i = " << i << "; j = " << j);
|
||||
EXPECT_EQ(absl::MakeInt128(uint64_t{1} << i, 0),
|
||||
absl::MakeInt128(uint64_t{1} << j, 0) >> (j - i));
|
||||
EXPECT_EQ(absl::MakeInt128(uint64_t{1} << i, 0),
|
||||
absl::MakeInt128(uint64_t{1} << j, 0) >>= (j - i));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
TEST(Int128, NumericLimitsTest) {
|
||||
static_assert(std::numeric_limits<absl::int128>::is_specialized, "");
|
||||
static_assert(std::numeric_limits<absl::int128>::is_signed, "");
|
||||
static_assert(std::numeric_limits<absl::int128>::is_integer, "");
|
||||
EXPECT_EQ(static_cast<int>(127 * std::log10(2)),
|
||||
std::numeric_limits<absl::int128>::digits10);
|
||||
EXPECT_EQ(absl::Int128Min(), std::numeric_limits<absl::int128>::min());
|
||||
EXPECT_EQ(absl::Int128Min(), std::numeric_limits<absl::int128>::lowest());
|
||||
EXPECT_EQ(absl::Int128Max(), std::numeric_limits<absl::int128>::max());
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
|
|
|||
|
|
@ -162,7 +162,8 @@
|
|||
// iOS does not support dispatch, even on x86, since applications
|
||||
// should be bundled as fat binaries, with a different build tailored for
|
||||
// each specific supported platform/architecture.
|
||||
#if defined(__APPLE__) && (TARGET_OS_IPHONE || TARGET_OS_IPHONE_SIMULATOR)
|
||||
#if (defined(TARGET_OS_IPHONE) && TARGET_OS_IPHONE) || \
|
||||
(defined(TARGET_OS_IPHONE_SIMULATOR) && TARGET_OS_IPHONE_SIMULATOR)
|
||||
#undef ABSL_RANDOM_INTERNAL_AES_DISPATCH
|
||||
#define ABSL_RANDOM_INTERNAL_AES_DISPATCH 0
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -32,6 +32,10 @@ void ReducePadding(size_t n, size_t *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;
|
||||
};
|
||||
|
|
@ -39,6 +43,8 @@ struct MakeUnsigned<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 {};
|
||||
|
||||
class ConvertedIntInfo {
|
||||
|
|
@ -363,6 +369,11 @@ IntegralConvertResult FormatConvertImpl(unsigned long long v, // NOLINT
|
|||
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) {
|
||||
|
|
@ -372,6 +383,7 @@ IntegralConvertResult FormatConvertImpl(absl::uint128 v,
|
|||
ABSL_INTERNAL_FORMAT_DISPATCH_OVERLOADS_EXPAND_();
|
||||
|
||||
|
||||
|
||||
} // namespace str_format_internal
|
||||
|
||||
} // namespace absl
|
||||
|
|
|
|||
|
|
@ -144,6 +144,8 @@ IntegralConvertResult FormatConvertImpl(long long v, // NOLINT
|
|||
IntegralConvertResult FormatConvertImpl(unsigned long long v, // NOLINT
|
||||
ConversionSpec conv,
|
||||
FormatSinkImpl* sink);
|
||||
IntegralConvertResult FormatConvertImpl(int128 v, ConversionSpec conv,
|
||||
FormatSinkImpl* sink);
|
||||
IntegralConvertResult FormatConvertImpl(uint128 v, ConversionSpec conv,
|
||||
FormatSinkImpl* sink);
|
||||
template <typename T, enable_if_t<std::is_same<T, bool>::value, int> = 0>
|
||||
|
|
@ -408,6 +410,7 @@ class FormatArgImpl {
|
|||
__VA_ARGS__); \
|
||||
ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(unsigned long long, /* NOLINT */ \
|
||||
__VA_ARGS__); \
|
||||
ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(int128, __VA_ARGS__); \
|
||||
ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(uint128, __VA_ARGS__); \
|
||||
ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(float, __VA_ARGS__); \
|
||||
ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(double, __VA_ARGS__); \
|
||||
|
|
@ -418,6 +421,7 @@ class FormatArgImpl {
|
|||
|
||||
ABSL_INTERNAL_FORMAT_DISPATCH_OVERLOADS_EXPAND_(extern);
|
||||
|
||||
|
||||
} // namespace str_format_internal
|
||||
} // namespace absl
|
||||
|
||||
|
|
|
|||
|
|
@ -390,7 +390,6 @@ typedef ::testing::Types<
|
|||
AllIntTypes;
|
||||
INSTANTIATE_TYPED_TEST_CASE_P(TypedFormatConvertTestWithAllIntTypes,
|
||||
TypedFormatConvertTest, AllIntTypes);
|
||||
|
||||
TEST_F(FormatConvertTest, VectorBool) {
|
||||
// Make sure vector<bool>'s values behave as bools.
|
||||
std::vector<bool> v = {true, false};
|
||||
|
|
@ -402,6 +401,42 @@ TEST_F(FormatConvertTest, VectorBool) {
|
|||
FormatArgImpl(cv[0]), FormatArgImpl(cv[1])})));
|
||||
}
|
||||
|
||||
|
||||
TEST_F(FormatConvertTest, Int128) {
|
||||
absl::int128 positive = static_cast<absl::int128>(0x1234567890abcdef) * 1979;
|
||||
absl::int128 negative = -positive;
|
||||
absl::int128 max = absl::Int128Max(), min = absl::Int128Min();
|
||||
const FormatArgImpl args[] = {FormatArgImpl(positive),
|
||||
FormatArgImpl(negative), FormatArgImpl(max),
|
||||
FormatArgImpl(min)};
|
||||
|
||||
struct Case {
|
||||
const char* format;
|
||||
const char* expected;
|
||||
} cases[] = {
|
||||
{"%1$d", "2595989796776606496405"},
|
||||
{"%1$30d", " 2595989796776606496405"},
|
||||
{"%1$-30d", "2595989796776606496405 "},
|
||||
{"%1$u", "2595989796776606496405"},
|
||||
{"%1$x", "8cba9876066020f695"},
|
||||
{"%2$d", "-2595989796776606496405"},
|
||||
{"%2$30d", " -2595989796776606496405"},
|
||||
{"%2$-30d", "-2595989796776606496405 "},
|
||||
{"%2$u", "340282366920938460867384810655161715051"},
|
||||
{"%2$x", "ffffffffffffff73456789f99fdf096b"},
|
||||
{"%3$d", "170141183460469231731687303715884105727"},
|
||||
{"%3$u", "170141183460469231731687303715884105727"},
|
||||
{"%3$x", "7fffffffffffffffffffffffffffffff"},
|
||||
{"%4$d", "-170141183460469231731687303715884105728"},
|
||||
{"%4$x", "80000000000000000000000000000000"},
|
||||
};
|
||||
|
||||
for (auto c : cases) {
|
||||
UntypedFormatSpecImpl format(c.format);
|
||||
EXPECT_EQ(c.expected, FormatPack(format, absl::MakeSpan(args)));
|
||||
}
|
||||
}
|
||||
|
||||
TEST_F(FormatConvertTest, Uint128) {
|
||||
absl::uint128 v = static_cast<absl::uint128>(0x1234567890abcdef) * 1979;
|
||||
absl::uint128 max = absl::Uint128Max();
|
||||
|
|
|
|||
|
|
@ -290,7 +290,8 @@ class string_view {
|
|||
constexpr const_reference at(size_type i) const {
|
||||
return ABSL_PREDICT_TRUE(i < size())
|
||||
? ptr_[i]
|
||||
: (base_internal::ThrowStdOutOfRange("absl::string_view::at"),
|
||||
: ((void)base_internal::ThrowStdOutOfRange(
|
||||
"absl::string_view::at"),
|
||||
ptr_[i]);
|
||||
}
|
||||
|
||||
|
|
@ -511,7 +512,7 @@ class string_view {
|
|||
(std::numeric_limits<difference_type>::max)();
|
||||
|
||||
static constexpr size_type CheckLengthInternal(size_type len) {
|
||||
return ABSL_ASSERT(len <= kMaxSize), len;
|
||||
return (void)ABSL_ASSERT(len <= kMaxSize), len;
|
||||
}
|
||||
|
||||
static constexpr size_type StrlenInternal(const char* str) {
|
||||
|
|
|
|||
|
|
@ -116,7 +116,10 @@ std::unique_ptr<cctz::ZoneInfoSource> TestFactory(
|
|||
|
||||
} // namespace
|
||||
|
||||
#if !defined(__MINGW32__)
|
||||
// MinGW does not support the weak symbol extension mechanism.
|
||||
ZoneInfoSourceFactory zone_info_source_factory = TestFactory;
|
||||
#endif
|
||||
|
||||
} // namespace cctz_extension
|
||||
} // namespace time_internal
|
||||
|
|
|
|||
|
|
@ -1412,8 +1412,7 @@ constexpr Duration FromInt64(int64_t v, std::ratio<3600>) {
|
|||
// IsValidRep64<T>(0) is true if the expression `int64_t{std::declval<T>()}` is
|
||||
// valid. That is, if a T can be assigned to an int64_t without narrowing.
|
||||
template <typename T>
|
||||
constexpr auto IsValidRep64(int)
|
||||
-> decltype(int64_t{std::declval<T>()}, bool()) {
|
||||
constexpr auto IsValidRep64(int) -> decltype(int64_t{std::declval<T>()} == 0) {
|
||||
return true;
|
||||
}
|
||||
template <typename T>
|
||||
|
|
|
|||
Loading…
Reference in a new issue