Skip to content

A
abseil-cpp
Commit e01d9552 by Abseil Team Committed by Derek Mauro
Options

Export of internal Abseil changes. 

--
eca34da4ccb7bb6a580f1364dff9ca053418fa3b by Abseil Team <absl-team@google.com>:

Internal change.

PiperOrigin-RevId: 214305433

--
35393bdd21a87c4286f945fd34dda93afc4e0cd6 by Abseil Team <absl-team@google.com>:

Move some implementation details of string_view around to facilitate compiling on NVCC.

Abseil does not officially support NVCC as a reminder.

PiperOrigin-RevId: 214184876

--
61846cab9ab9476a4676ecade7173f68978cd038 by Jorg Brown <jorg@google.com>:

Move the initialization values for constants back to their declaration.

PiperOrigin-RevId: 214135927

--
7ac7df6c5f78f2faf419268c04618b936cb26065 by Abseil Team <absl-team@google.com>:

Performance improvements on format parser.

PiperOrigin-RevId: 214032366

--
90b4c0cf20e9feaa257a7ece40adaf7db40a60a7 by Xiaoyi Zhang <zhangxy@google.com>:

Add static_assert check to absl::visit to make sure all overloads of the visitor return the same type, as required by the C++ standard.

PiperOrigin-RevId: 213677001

--
787995342101b4c181291cde9ecea3048536e4bd by Abseil Team <absl-team@google.com>:

Update comment to indicate finite durations are less than InfiniteDuration.

PiperOrigin-RevId: 213660328

--
d78f0dce7cc31218807e96d93b9e8513b6c80b24 by Jon Cohen <cohenjon@google.com>:

s/invariant/contract in the exceptions safety testing framework.  This is a better term as these can be type invariants or function post conditions.  They also are very similar ground as to what is covered by c++20 Contracts (and could even be replaced by them.

PiperOrigin-RevId: 213631019

--
0b3ff1a640de9a7391a6c233568802cf86245b0e by Abseil Team <absl-team@google.com>:

Add noinline attribute for GetStackTrace/GetStackFrames/... so the skipped frames will not change because of inlining difference.

PiperOrigin-RevId: 213009637
GitOrigin-RevId: eca34da4ccb7bb6a580f1364dff9ca053418fa3b
Change-Id: Iff1022fd24e440fcbdf3c4ab2a915ca8954daa31
parent 8ff13740
Showing with 182 additions and 154 deletions
WORKSPACE
...@@ -5,11 +5,11 @@ load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive") ...@@ -5,11 +5,11 @@ load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")
http_archive( http_archive(
name = "bazel_toolchains", name = "bazel_toolchains",
urls = [ urls = [
"https://mirror.bazel.build/github.com/bazelbuild/bazel-toolchains/archive/287b64e0a211fb7c23b74695f8d5f5205b61f4eb.tar.gz", "https://mirror.bazel.build/github.com/bazelbuild/bazel-toolchains/archive/bc09b995c137df042bb80a395b73d7ce6f26afbe.tar.gz",
"https://github.com/bazelbuild/bazel-toolchains/archive/287b64e0a211fb7c23b74695f8d5f5205b61f4eb.tar.gz", "https://github.com/bazelbuild/bazel-toolchains/archive/bc09b995c137df042bb80a395b73d7ce6f26afbe.tar.gz",
], ],
strip_prefix = "bazel-toolchains-287b64e0a211fb7c23b74695f8d5f5205b61f4eb", strip_prefix = "bazel-toolchains-bc09b995c137df042bb80a395b73d7ce6f26afbe",
sha256 = "aca8ac6afd7745027ee4a43032b51a725a61a75a30f02cc58681ee87e4dcdf4b", sha256 = "4329663fe6c523425ad4d3c989a8ac026b04e1acedeceb56aa4b190fa7f3973c",
) )
# GoogleTest/GoogleMock framework. Used by most unit-tests. # GoogleTest/GoogleMock framework. Used by most unit-tests.
......
absl/base/exception_safety_testing_test.cc
...@@ -548,21 +548,21 @@ TEST(ExceptionSafetyTesterTest, IncompleteTypesAreNotTestable) { ...@@ -548,21 +548,21 @@ TEST(ExceptionSafetyTesterTest, IncompleteTypesAreNotTestable) {
// Test that providing operation and inveriants still does not allow for the // Test that providing operation and inveriants still does not allow for the
// the invocation of .Test() and .Test(op) because it lacks a factory // the invocation of .Test() and .Test(op) because it lacks a factory
auto without_fac = auto without_fac =
testing::MakeExceptionSafetyTester().WithOperation(op).WithInvariants( testing::MakeExceptionSafetyTester().WithOperation(op).WithContracts(
inv, testing::strong_guarantee); inv, testing::strong_guarantee);
EXPECT_FALSE(HasNullaryTest(without_fac)); EXPECT_FALSE(HasNullaryTest(without_fac));
EXPECT_FALSE(HasUnaryTest(without_fac)); EXPECT_FALSE(HasUnaryTest(without_fac));
// Test that providing invariants and factory allows the invocation of // Test that providing contracts and factory allows the invocation of
// .Test(op) but does not allow for .Test() because it lacks an operation // .Test(op) but does not allow for .Test() because it lacks an operation
auto without_op = testing::MakeExceptionSafetyTester() auto without_op = testing::MakeExceptionSafetyTester()
.WithInvariants(inv, testing::strong_guarantee) .WithContracts(inv, testing::strong_guarantee)
.WithFactory(fac); .WithFactory(fac);
EXPECT_FALSE(HasNullaryTest(without_op)); EXPECT_FALSE(HasNullaryTest(without_op));
EXPECT_TRUE(HasUnaryTest(without_op)); EXPECT_TRUE(HasUnaryTest(without_op));
// Test that providing operation and factory still does not allow for the // Test that providing operation and factory still does not allow for the
// the invocation of .Test() and .Test(op) because it lacks invariants // the invocation of .Test() and .Test(op) because it lacks contracts
auto without_inv = auto without_inv =
testing::MakeExceptionSafetyTester().WithOperation(op).WithFactory(fac); testing::MakeExceptionSafetyTester().WithOperation(op).WithFactory(fac);
EXPECT_FALSE(HasNullaryTest(without_inv)); EXPECT_FALSE(HasNullaryTest(without_inv));
...@@ -577,7 +577,7 @@ std::unique_ptr<ExampleStruct> ExampleFunctionFactory() { ...@@ -577,7 +577,7 @@ std::unique_ptr<ExampleStruct> ExampleFunctionFactory() {
void ExampleFunctionOperation(ExampleStruct*) {} void ExampleFunctionOperation(ExampleStruct*) {}
testing::AssertionResult ExampleFunctionInvariant(ExampleStruct*) { testing::AssertionResult ExampleFunctionContract(ExampleStruct*) {
return testing::AssertionSuccess(); return testing::AssertionSuccess();
} }
...@@ -593,16 +593,16 @@ struct { ...@@ -593,16 +593,16 @@ struct {
struct { struct {
testing::AssertionResult operator()(ExampleStruct* example_struct) const { testing::AssertionResult operator()(ExampleStruct* example_struct) const {
return ExampleFunctionInvariant(example_struct); return ExampleFunctionContract(example_struct);
} }
} example_struct_invariant; } example_struct_contract;
auto example_lambda_factory = []() { return ExampleFunctionFactory(); }; auto example_lambda_factory = []() { return ExampleFunctionFactory(); };
auto example_lambda_operation = [](ExampleStruct*) {}; auto example_lambda_operation = [](ExampleStruct*) {};
auto example_lambda_invariant = [](ExampleStruct* example_struct) { auto example_lambda_contract = [](ExampleStruct* example_struct) {
return ExampleFunctionInvariant(example_struct); return ExampleFunctionContract(example_struct);
}; };
// Testing that function references, pointers, structs with operator() and // Testing that function references, pointers, structs with operator() and
...@@ -612,28 +612,28 @@ TEST(ExceptionSafetyTesterTest, MixedFunctionTypes) { ...@@ -612,28 +612,28 @@ TEST(ExceptionSafetyTesterTest, MixedFunctionTypes) {
EXPECT_TRUE(testing::MakeExceptionSafetyTester() EXPECT_TRUE(testing::MakeExceptionSafetyTester()
.WithFactory(ExampleFunctionFactory) .WithFactory(ExampleFunctionFactory)
.WithOperation(ExampleFunctionOperation) .WithOperation(ExampleFunctionOperation)
.WithInvariants(ExampleFunctionInvariant) .WithContracts(ExampleFunctionContract)
.Test()); .Test());
// function pointer // function pointer
EXPECT_TRUE(testing::MakeExceptionSafetyTester() EXPECT_TRUE(testing::MakeExceptionSafetyTester()
.WithFactory(&ExampleFunctionFactory) .WithFactory(&ExampleFunctionFactory)
.WithOperation(&ExampleFunctionOperation) .WithOperation(&ExampleFunctionOperation)
.WithInvariants(&ExampleFunctionInvariant) .WithContracts(&ExampleFunctionContract)
.Test()); .Test());
// struct // struct
EXPECT_TRUE(testing::MakeExceptionSafetyTester() EXPECT_TRUE(testing::MakeExceptionSafetyTester()
.WithFactory(example_struct_factory) .WithFactory(example_struct_factory)
.WithOperation(example_struct_operation) .WithOperation(example_struct_operation)
.WithInvariants(example_struct_invariant) .WithContracts(example_struct_contract)
.Test()); .Test());
// lambda // lambda
EXPECT_TRUE(testing::MakeExceptionSafetyTester() EXPECT_TRUE(testing::MakeExceptionSafetyTester()
.WithFactory(example_lambda_factory) .WithFactory(example_lambda_factory)
.WithOperation(example_lambda_operation) .WithOperation(example_lambda_operation)
.WithInvariants(example_lambda_invariant) .WithContracts(example_lambda_contract)
.Test()); .Test());
} }
...@@ -658,9 +658,9 @@ struct { ...@@ -658,9 +658,9 @@ struct {
} invoker; } invoker;
auto tester = auto tester =
testing::MakeExceptionSafetyTester().WithOperation(invoker).WithInvariants( testing::MakeExceptionSafetyTester().WithOperation(invoker).WithContracts(
CheckNonNegativeInvariants); CheckNonNegativeInvariants);
auto strong_tester = tester.WithInvariants(testing::strong_guarantee); auto strong_tester = tester.WithContracts(testing::strong_guarantee);
struct FailsBasicGuarantee : public NonNegative { struct FailsBasicGuarantee : public NonNegative {
void operator()() { void operator()() {
...@@ -690,7 +690,7 @@ TEST(ExceptionCheckTest, StrongGuaranteeFailure) { ...@@ -690,7 +690,7 @@ TEST(ExceptionCheckTest, StrongGuaranteeFailure) {
EXPECT_FALSE(strong_tester.WithInitialValue(FollowsBasicGuarantee{}).Test()); EXPECT_FALSE(strong_tester.WithInitialValue(FollowsBasicGuarantee{}).Test());
} }
struct BasicGuaranteeWithExtraInvariants : public NonNegative { struct BasicGuaranteeWithExtraContracts : public NonNegative {
// After operator(), i is incremented. If operator() throws, i is set to 9999 // After operator(), i is incremented. If operator() throws, i is set to 9999
void operator()() { void operator()() {
int old_i = i; int old_i = i;
...@@ -701,21 +701,21 @@ struct BasicGuaranteeWithExtraInvariants : public NonNegative { ...@@ -701,21 +701,21 @@ struct BasicGuaranteeWithExtraInvariants : public NonNegative {
static constexpr int kExceptionSentinel = 9999; static constexpr int kExceptionSentinel = 9999;
}; };
constexpr int BasicGuaranteeWithExtraInvariants::kExceptionSentinel; constexpr int BasicGuaranteeWithExtraContracts::kExceptionSentinel;
TEST(ExceptionCheckTest, BasicGuaranteeWithExtraInvariants) { TEST(ExceptionCheckTest, BasicGuaranteeWithExtraContracts) {
auto tester_with_val = auto tester_with_val =
tester.WithInitialValue(BasicGuaranteeWithExtraInvariants{}); tester.WithInitialValue(BasicGuaranteeWithExtraContracts{});
EXPECT_TRUE(tester_with_val.Test()); EXPECT_TRUE(tester_with_val.Test());
EXPECT_TRUE( EXPECT_TRUE(
tester_with_val tester_with_val
.WithInvariants([](BasicGuaranteeWithExtraInvariants* o) { .WithContracts([](BasicGuaranteeWithExtraContracts* o) {
if (o->i == BasicGuaranteeWithExtraInvariants::kExceptionSentinel) { if (o->i == BasicGuaranteeWithExtraContracts::kExceptionSentinel) {
return testing::AssertionSuccess(); return testing::AssertionSuccess();
} }
return testing::AssertionFailure() return testing::AssertionFailure()
<< "i should be " << "i should be "
<< BasicGuaranteeWithExtraInvariants::kExceptionSentinel << BasicGuaranteeWithExtraContracts::kExceptionSentinel
<< ", but is " << o->i; << ", but is " << o->i;
}) })
.Test()); .Test());
...@@ -740,7 +740,7 @@ struct HasReset : public NonNegative { ...@@ -740,7 +740,7 @@ struct HasReset : public NonNegative {
void reset() { i = 0; } void reset() { i = 0; }
}; };
testing::AssertionResult CheckHasResetInvariants(HasReset* h) { testing::AssertionResult CheckHasResetContracts(HasReset* h) {
h->reset(); h->reset();
return testing::AssertionResult(h->i == 0); return testing::AssertionResult(h->i == 0);
} }
...@@ -759,14 +759,14 @@ TEST(ExceptionCheckTest, ModifyingChecker) { ...@@ -759,14 +759,14 @@ TEST(ExceptionCheckTest, ModifyingChecker) {
}; };
EXPECT_FALSE(tester.WithInitialValue(FollowsBasicGuarantee{}) EXPECT_FALSE(tester.WithInitialValue(FollowsBasicGuarantee{})
.WithInvariants(set_to_1000, is_1000) .WithContracts(set_to_1000, is_1000)
.Test()); .Test());
EXPECT_TRUE(strong_tester.WithInitialValue(FollowsStrongGuarantee{}) EXPECT_TRUE(strong_tester.WithInitialValue(FollowsStrongGuarantee{})
.WithInvariants(increment) .WithContracts(increment)
.Test()); .Test());
EXPECT_TRUE(testing::MakeExceptionSafetyTester() EXPECT_TRUE(testing::MakeExceptionSafetyTester()
.WithInitialValue(HasReset{}) .WithInitialValue(HasReset{})
.WithInvariants(CheckHasResetInvariants) .WithContracts(CheckHasResetContracts)
.Test(invoker)); .Test(invoker));
} }
...@@ -799,7 +799,7 @@ TEST(ExceptionCheckTest, NonEqualityComparable) { ...@@ -799,7 +799,7 @@ TEST(ExceptionCheckTest, NonEqualityComparable) {
return testing::AssertionResult(nec->i == NonEqualityComparable().i); return testing::AssertionResult(nec->i == NonEqualityComparable().i);
}; };
auto strong_nec_tester = tester.WithInitialValue(NonEqualityComparable{}) auto strong_nec_tester = tester.WithInitialValue(NonEqualityComparable{})
.WithInvariants(nec_is_strong); .WithContracts(nec_is_strong);
EXPECT_TRUE(strong_nec_tester.Test()); EXPECT_TRUE(strong_nec_tester.Test());
EXPECT_FALSE(strong_nec_tester.Test( EXPECT_FALSE(strong_nec_tester.Test(
...@@ -833,14 +833,14 @@ struct { ...@@ -833,14 +833,14 @@ struct {
testing::AssertionResult operator()(ExhaustivenessTester<T>*) const { testing::AssertionResult operator()(ExhaustivenessTester<T>*) const {
return testing::AssertionSuccess(); return testing::AssertionSuccess();
} }
} CheckExhaustivenessTesterInvariants; } CheckExhaustivenessTesterContracts;
template <typename T> template <typename T>
unsigned char ExhaustivenessTester<T>::successes = 0; unsigned char ExhaustivenessTester<T>::successes = 0;
TEST(ExceptionCheckTest, Exhaustiveness) { TEST(ExceptionCheckTest, Exhaustiveness) {
auto exhaust_tester = testing::MakeExceptionSafetyTester() auto exhaust_tester = testing::MakeExceptionSafetyTester()
.WithInvariants(CheckExhaustivenessTesterInvariants) .WithContracts(CheckExhaustivenessTesterContracts)
.WithOperation(invoker); .WithOperation(invoker);
EXPECT_TRUE( EXPECT_TRUE(
...@@ -849,7 +849,7 @@ TEST(ExceptionCheckTest, Exhaustiveness) { ...@@ -849,7 +849,7 @@ TEST(ExceptionCheckTest, Exhaustiveness) {
EXPECT_TRUE( EXPECT_TRUE(
exhaust_tester.WithInitialValue(ExhaustivenessTester<ThrowingValue<>>{}) exhaust_tester.WithInitialValue(ExhaustivenessTester<ThrowingValue<>>{})
.WithInvariants(testing::strong_guarantee) .WithContracts(testing::strong_guarantee)
.Test()); .Test());
EXPECT_EQ(ExhaustivenessTester<ThrowingValue<>>::successes, 0xF); EXPECT_EQ(ExhaustivenessTester<ThrowingValue<>>::successes, 0xF);
} }
......
absl/container/fixed_array_exception_safety_test.cc
...@@ -97,7 +97,7 @@ testing::AssertionResult ReadMemory(FixedArr* fixed_arr) { ...@@ -97,7 +97,7 @@ testing::AssertionResult ReadMemory(FixedArr* fixed_arr) {
TEST(FixedArrayExceptionSafety, Fill) { TEST(FixedArrayExceptionSafety, Fill) {
auto test_fill = testing::MakeExceptionSafetyTester() auto test_fill = testing::MakeExceptionSafetyTester()
.WithInvariants(ReadMemory) .WithContracts(ReadMemory)
.WithOperation([&](FixedArr* fixed_arr_ptr) { .WithOperation([&](FixedArr* fixed_arr_ptr) {
auto thrower = auto thrower =
Thrower(kUpdatedValue, testing::nothrow_ctor); Thrower(kUpdatedValue, testing::nothrow_ctor);
......
absl/debugging/stacktrace.cc
...@@ -80,11 +80,13 @@ ABSL_ATTRIBUTE_ALWAYS_INLINE inline int Unwind(void** result, int* sizes, ...@@ -80,11 +80,13 @@ ABSL_ATTRIBUTE_ALWAYS_INLINE inline int Unwind(void** result, int* sizes,
} // anonymous namespace } // anonymous namespace
ABSL_ATTRIBUTE_NOINLINE
int GetStackFrames(void** result, int* sizes, int max_depth, int skip_count) { int GetStackFrames(void** result, int* sizes, int max_depth, int skip_count) {
return Unwind<true, false>(result, sizes, max_depth, skip_count, nullptr, return Unwind<true, false>(result, sizes, max_depth, skip_count, nullptr,
nullptr); nullptr);
} }
ABSL_ATTRIBUTE_NOINLINE
int GetStackFramesWithContext(void** result, int* sizes, int max_depth, int GetStackFramesWithContext(void** result, int* sizes, int max_depth,
int skip_count, const void* uc, int skip_count, const void* uc,
int* min_dropped_frames) { int* min_dropped_frames) {
...@@ -92,11 +94,13 @@ int GetStackFramesWithContext(void** result, int* sizes, int max_depth, ...@@ -92,11 +94,13 @@ int GetStackFramesWithContext(void** result, int* sizes, int max_depth,
min_dropped_frames); min_dropped_frames);
} }
ABSL_ATTRIBUTE_NOINLINE
int GetStackTrace(void** result, int max_depth, int skip_count) { int GetStackTrace(void** result, int max_depth, int skip_count) {
return Unwind<false, false>(result, nullptr, max_depth, skip_count, nullptr, return Unwind<false, false>(result, nullptr, max_depth, skip_count, nullptr,
nullptr); nullptr);
} }
ABSL_ATTRIBUTE_NOINLINE
int GetStackTraceWithContext(void** result, int max_depth, int skip_count, int GetStackTraceWithContext(void** result, int max_depth, int skip_count,
const void* uc, int* min_dropped_frames) { const void* uc, int* min_dropped_frames) {
return Unwind<false, true>(result, nullptr, max_depth, skip_count, uc, return Unwind<false, true>(result, nullptr, max_depth, skip_count, uc,
......
absl/memory/memory_exception_safety_test.cc
...@@ -32,7 +32,7 @@ TEST(MakeUnique, CheckForLeaks) { ...@@ -32,7 +32,7 @@ TEST(MakeUnique, CheckForLeaks) {
.WithInitialValue(Thrower(kValue)) .WithInitialValue(Thrower(kValue))
// Ensures make_unique does not modify the input. The real // Ensures make_unique does not modify the input. The real
// test, though, is ConstructorTracker checking for leaks. // test, though, is ConstructorTracker checking for leaks.
.WithInvariants(testing::strong_guarantee); .WithContracts(testing::strong_guarantee);
EXPECT_TRUE(tester.Test([](Thrower* thrower) { EXPECT_TRUE(tester.Test([](Thrower* thrower) {
static_cast<void>(absl::make_unique<Thrower>(*thrower)); static_cast<void>(absl::make_unique<Thrower>(*thrower));
......
absl/strings/internal/str_format/parser.cc
...@@ -84,16 +84,24 @@ bool ConsumeConversion(string_view *src, UnboundConversion *conv, ...@@ -84,16 +84,24 @@ bool ConsumeConversion(string_view *src, UnboundConversion *conv,
const char *pos = src->data(); const char *pos = src->data();
const char *const end = pos + src->size(); const char *const end = pos + src->size();
char c; char c;
// Read the next char into `c` and update `pos`. Reads '\0' if at end. // Read the next char into `c` and update `pos`. Returns false if there are
const auto get_char = [&] { c = pos == end ? '\0' : *pos++; }; // no more chars to read.
#define ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR() \
do { \
if (ABSL_PREDICT_FALSE(pos == end)) return false; \
c = *pos++; \
} while (0)
const auto parse_digits = [&] { const auto parse_digits = [&] {
int digits = c - '0'; int digits = c - '0';
// We do not want to overflow `digits` so we consume at most digits10-1 // We do not want to overflow `digits` so we consume at most digits10
// digits. If there are more digits the parsing will fail later on when the // digits. If there are more digits the parsing will fail later on when the
// digit doesn't match the expected characters. // digit doesn't match the expected characters.
int num_digits = std::numeric_limits<int>::digits10 - 2; int num_digits = std::numeric_limits<int>::digits10;
for (get_char(); num_digits && std::isdigit(c); get_char()) { for (;;) {
if (ABSL_PREDICT_FALSE(pos == end || !num_digits)) break;
c = *pos++;
if (!std::isdigit(c)) break;
--num_digits; --num_digits;
digits = 10 * digits + c - '0'; digits = 10 * digits + c - '0';
} }
...@@ -101,14 +109,14 @@ bool ConsumeConversion(string_view *src, UnboundConversion *conv, ...@@ -101,14 +109,14 @@ bool ConsumeConversion(string_view *src, UnboundConversion *conv,
}; };
if (is_positional) { if (is_positional) {
get_char(); ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR();
if (c < '1' || c > '9') return false; if (ABSL_PREDICT_FALSE(c < '1' || c > '9')) return false;
conv->arg_position = parse_digits(); conv->arg_position = parse_digits();
assert(conv->arg_position > 0); assert(conv->arg_position > 0);
if (c != '$') return false; if (ABSL_PREDICT_FALSE(c != '$')) return false;
} }
get_char(); ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR();
// We should start with the basic flag on. // We should start with the basic flag on.
assert(conv->flags.basic); assert(conv->flags.basic);
...@@ -119,32 +127,39 @@ bool ConsumeConversion(string_view *src, UnboundConversion *conv, ...@@ -119,32 +127,39 @@ bool ConsumeConversion(string_view *src, UnboundConversion *conv,
if (c < 'A') { if (c < 'A') {
conv->flags.basic = false; conv->flags.basic = false;
for (; c <= '0'; get_char()) { for (; c <= '0';) {
// FIXME: We might be able to speed this up reusing the kIds lookup table
// from above.
// It might require changing Flags to be a plain integer where we can |= a
// value.
switch (c) { switch (c) {
case '-': case '-':
conv->flags.left = true; conv->flags.left = true;
continue; break;
case '+': case '+':
conv->flags.show_pos = true; conv->flags.show_pos = true;
continue; break;
case ' ': case ' ':
conv->flags.sign_col = true; conv->flags.sign_col = true;
continue; break;
case '#': case '#':
conv->flags.alt = true; conv->flags.alt = true;
continue; break;
case '0': case '0':
conv->flags.zero = true; conv->flags.zero = true;
continue; break;
default:
goto flags_done;
} }
break; ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR();
} }
flags_done:
if (c <= '9') { if (c <= '9') {
if (c >= '0') { if (c >= '0') {
int maybe_width = parse_digits(); int maybe_width = parse_digits();
if (!is_positional && c == '$') { if (!is_positional && c == '$') {
if (*next_arg != 0) return false; if (ABSL_PREDICT_FALSE(*next_arg != 0)) return false;
// Positional conversion. // Positional conversion.
*next_arg = -1; *next_arg = -1;
conv->flags = Flags(); conv->flags = Flags();
...@@ -153,12 +168,12 @@ bool ConsumeConversion(string_view *src, UnboundConversion *conv, ...@@ -153,12 +168,12 @@ bool ConsumeConversion(string_view *src, UnboundConversion *conv,
} }
conv->width.set_value(maybe_width); conv->width.set_value(maybe_width);
} else if (c == '*') { } else if (c == '*') {
get_char(); ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR();
if (is_positional) { if (is_positional) {
if (c < '1' || c > '9') return false; if (ABSL_PREDICT_FALSE(c < '1' || c > '9')) return false;
conv->width.set_from_arg(parse_digits()); conv->width.set_from_arg(parse_digits());
if (c != '$') return false; if (ABSL_PREDICT_FALSE(c != '$')) return false;
get_char(); ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR();
} else { } else {
conv->width.set_from_arg(++*next_arg); conv->width.set_from_arg(++*next_arg);
} }
...@@ -166,16 +181,16 @@ bool ConsumeConversion(string_view *src, UnboundConversion *conv, ...@@ -166,16 +181,16 @@ bool ConsumeConversion(string_view *src, UnboundConversion *conv,
} }
if (c == '.') { if (c == '.') {
get_char(); ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR();
if (std::isdigit(c)) { if (std::isdigit(c)) {
conv->precision.set_value(parse_digits()); conv->precision.set_value(parse_digits());
} else if (c == '*') { } else if (c == '*') {
get_char(); ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR();
if (is_positional) { if (is_positional) {
if (c < '1' || c > '9') return false; if (ABSL_PREDICT_FALSE(c < '1' || c > '9')) return false;
conv->precision.set_from_arg(parse_digits()); conv->precision.set_from_arg(parse_digits());
if (c != '$') return false; if (c != '$') return false;
get_char(); ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR();
} else { } else {
conv->precision.set_from_arg(++*next_arg); conv->precision.set_from_arg(++*next_arg);
} }
...@@ -188,23 +203,23 @@ bool ConsumeConversion(string_view *src, UnboundConversion *conv, ...@@ -188,23 +203,23 @@ bool ConsumeConversion(string_view *src, UnboundConversion *conv,
std::int8_t id = kIds[static_cast<unsigned char>(c)]; std::int8_t id = kIds[static_cast<unsigned char>(c)];
if (id < 0) { if (id < 0) {
if (id == none) return false; if (ABSL_PREDICT_FALSE(id == none)) return false;
// It is a length modifier. // It is a length modifier.
using str_format_internal::LengthMod; using str_format_internal::LengthMod;
LengthMod length_mod = LengthMod::FromId(static_cast<LM>(~id)); LengthMod length_mod = LengthMod::FromId(static_cast<LM>(~id));
get_char(); ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR();
if (c == 'h' && length_mod.id() == LengthMod::h) { if (c == 'h' && length_mod.id() == LengthMod::h) {
conv->length_mod = LengthMod::FromId(LengthMod::hh); conv->length_mod = LengthMod::FromId(LengthMod::hh);
get_char(); ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR();
} else if (c == 'l' && length_mod.id() == LengthMod::l) { } else if (c == 'l' && length_mod.id() == LengthMod::l) {
conv->length_mod = LengthMod::FromId(LengthMod::ll); conv->length_mod = LengthMod::FromId(LengthMod::ll);
get_char(); ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR();
} else { } else {
conv->length_mod = length_mod; conv->length_mod = length_mod;
} }
id = kIds[static_cast<unsigned char>(c)]; id = kIds[static_cast<unsigned char>(c)];
if (id < 0) return false; if (ABSL_PREDICT_FALSE(id < 0)) return false;
} }
assert(CheckFastPathSetting(*conv)); assert(CheckFastPathSetting(*conv));
......
absl/strings/internal/str_format/parser_test.cc
...@@ -84,9 +84,9 @@ class ConsumeUnboundConversionTest : public ::testing::Test { ...@@ -84,9 +84,9 @@ class ConsumeUnboundConversionTest : public ::testing::Test {
TEST_F(ConsumeUnboundConversionTest, ConsumeSpecification) { TEST_F(ConsumeUnboundConversionTest, ConsumeSpecification) {
struct Expectation { struct Expectation {
int line; int line;
const char *src; string_view src;
const char *out; string_view out;
const char *src_post; string_view src_post;
}; };
const Expectation kExpect[] = { const Expectation kExpect[] = {
{__LINE__, "", "", "" }, {__LINE__, "", "", "" },
...@@ -236,6 +236,16 @@ TEST_F(ConsumeUnboundConversionTest, WidthAndPrecision) { ...@@ -236,6 +236,16 @@ TEST_F(ConsumeUnboundConversionTest, WidthAndPrecision) {
EXPECT_EQ(9, o.precision.get_from_arg()); EXPECT_EQ(9, o.precision.get_from_arg());
EXPECT_FALSE(Run(".*0$d")) << "no arg 0"; EXPECT_FALSE(Run(".*0$d")) << "no arg 0";
// Large values
EXPECT_TRUE(Run("999999999.999999999d"));
EXPECT_FALSE(o.width.is_from_arg());
EXPECT_EQ(999999999, o.width.value());
EXPECT_FALSE(o.precision.is_from_arg());
EXPECT_EQ(999999999, o.precision.value());
EXPECT_FALSE(Run("1000000000.999999999d"));
EXPECT_FALSE(Run("999999999.1000000000d"));
} }
TEST_F(ConsumeUnboundConversionTest, Flags) { TEST_F(ConsumeUnboundConversionTest, Flags) {
......
absl/strings/string_view.h
...@@ -173,8 +173,19 @@ class string_view { ...@@ -173,8 +173,19 @@ class string_view {
// Implicit constructor of a `string_view` from nul-terminated `str`. When // Implicit constructor of a `string_view` from nul-terminated `str`. When
// accepting possibly null strings, use `absl::NullSafeStringView(str)` // accepting possibly null strings, use `absl::NullSafeStringView(str)`
// instead (see below). // instead (see below).
#if ABSL_HAVE_BUILTIN(__builtin_strlen) || \
(defined(__GNUC__) && !defined(__clang__))
// GCC has __builtin_strlen according to
// https://gcc.gnu.org/onlinedocs/gcc-4.7.0/gcc/Other-Builtins.html, but
// ABSL_HAVE_BUILTIN doesn't detect that, so we use the extra checks above.
// __builtin_strlen is constexpr.
constexpr string_view(const char* str) // NOLINT(runtime/explicit)
: ptr_(str),
length_(CheckLengthInternal(str ? __builtin_strlen(str) : 0)) {}
#else
constexpr string_view(const char* str) // NOLINT(runtime/explicit) constexpr string_view(const char* str) // NOLINT(runtime/explicit)
: ptr_(str), length_(CheckLengthInternal(StrLenInternal(str))) {} : ptr_(str), length_(CheckLengthInternal(str ? strlen(str) : 0)) {}
#endif
// Implicit constructor of a `string_view` from a `const char*` and length. // Implicit constructor of a `string_view` from a `const char*` and length.
constexpr string_view(const char* data, size_type len) constexpr string_view(const char* data, size_type len)
...@@ -481,22 +492,6 @@ class string_view { ...@@ -481,22 +492,6 @@ class string_view {
static constexpr size_type kMaxSize = static constexpr size_type kMaxSize =
std::numeric_limits<difference_type>::max(); std::numeric_limits<difference_type>::max();
// check whether __builtin_strlen is provided by the compiler.
// GCC doesn't have __has_builtin()
// (https://gcc.gnu.org/bugzilla/show_bug.cgi?id=66970),
// but has __builtin_strlen according to
// https://gcc.gnu.org/onlinedocs/gcc-4.7.0/gcc/Other-Builtins.html.
#if ABSL_HAVE_BUILTIN(__builtin_strlen) || \
(defined(__GNUC__) && !defined(__clang__))
static constexpr size_type StrLenInternal(const char* str) {
return str ? __builtin_strlen(str) : 0;
}
#else
static constexpr size_type StrLenInternal(const char* str) {
return str ? strlen(str) : 0;
}
#endif
static constexpr size_type CheckLengthInternal(size_type len) { static constexpr size_type CheckLengthInternal(size_type len) {
return ABSL_ASSERT(len <= kMaxSize), len; return ABSL_ASSERT(len <= kMaxSize), len;
} }
......
absl/synchronization/internal/graphcycles.cc
...@@ -204,8 +204,7 @@ class NodeSet { ...@@ -204,8 +204,7 @@ class NodeSet {
} }
private: private:
static const int32_t kEmpty; enum : int32_t { kEmpty = -1, kDel = -2 };
static const int32_t kDel;
Vec<int32_t> table_; Vec<int32_t> table_;
uint32_t occupied_; // Count of non-empty slots (includes deleted slots) uint32_t occupied_; // Count of non-empty slots (includes deleted slots)
...@@ -255,9 +254,6 @@ class NodeSet { ...@@ -255,9 +254,6 @@ class NodeSet {
NodeSet& operator=(const NodeSet&) = delete; NodeSet& operator=(const NodeSet&) = delete;
}; };
const int32_t NodeSet::kEmpty = -1;
const int32_t NodeSet::kDel = -2;
// We encode a node index and a node version in GraphId. The version // We encode a node index and a node version in GraphId. The version
// number is incremented when the GraphId is freed which automatically // number is incremented when the GraphId is freed which automatically
// invalidates all copies of the GraphId. // invalidates all copies of the GraphId.
......
absl/time/time.h
...@@ -322,6 +322,9 @@ Duration Ceil(Duration d, Duration unit); ...@@ -322,6 +322,9 @@ Duration Ceil(Duration d, Duration unit);
// 0 == d / inf // 0 == d / inf
// INT64_MAX == inf / d // INT64_MAX == inf / d
// //
// d < inf
// -inf < d
//
// // Division by zero returns infinity, or INT64_MIN/MAX where appropriate. // // Division by zero returns infinity, or INT64_MIN/MAX where appropriate.
// inf == d / 0 // inf == d / 0
// INT64_MAX == d / absl::ZeroDuration() // INT64_MAX == d / absl::ZeroDuration()
......
absl/types/any_exception_safety_test.cc
...@@ -107,7 +107,7 @@ TEST(AnyExceptionSafety, Assignment) { ...@@ -107,7 +107,7 @@ TEST(AnyExceptionSafety, Assignment) {
}; };
auto any_strong_tester = testing::MakeExceptionSafetyTester() auto any_strong_tester = testing::MakeExceptionSafetyTester()
.WithInitialValue(original) .WithInitialValue(original)
.WithInvariants(AnyInvariants, any_is_strong); .WithContracts(AnyInvariants, any_is_strong);
Thrower val(2); Thrower val(2);
absl::any any_val(val); absl::any any_val(val);
...@@ -129,7 +129,7 @@ TEST(AnyExceptionSafety, Assignment) { ...@@ -129,7 +129,7 @@ TEST(AnyExceptionSafety, Assignment) {
auto strong_empty_any_tester = auto strong_empty_any_tester =
testing::MakeExceptionSafetyTester() testing::MakeExceptionSafetyTester()
.WithInitialValue(absl::any{}) .WithInitialValue(absl::any{})
.WithInvariants(AnyInvariants, empty_any_is_strong); .WithContracts(AnyInvariants, empty_any_is_strong);
EXPECT_TRUE(strong_empty_any_tester.Test(assign_any)); EXPECT_TRUE(strong_empty_any_tester.Test(assign_any));
EXPECT_TRUE(strong_empty_any_tester.Test(assign_val)); EXPECT_TRUE(strong_empty_any_tester.Test(assign_val));
...@@ -142,7 +142,7 @@ TEST(AnyExceptionSafety, Emplace) { ...@@ -142,7 +142,7 @@ TEST(AnyExceptionSafety, Emplace) {
absl::any{absl::in_place_type_t<Thrower>(), 1, testing::nothrow_ctor}; absl::any{absl::in_place_type_t<Thrower>(), 1, testing::nothrow_ctor};
auto one_tester = testing::MakeExceptionSafetyTester() auto one_tester = testing::MakeExceptionSafetyTester()
.WithInitialValue(initial_val) .WithInitialValue(initial_val)
.WithInvariants(AnyInvariants, AnyIsEmpty); .WithContracts(AnyInvariants, AnyIsEmpty);
auto emp_thrower = [](absl::any* ap) { ap->emplace<Thrower>(2); }; auto emp_thrower = [](absl::any* ap) { ap->emplace<Thrower>(2); };
auto emp_throwervec = [](absl::any* ap) { auto emp_throwervec = [](absl::any* ap) {
......
absl/types/internal/variant.h
// Copyright 2017 The Abseil Authors. // Copyright 2018 The Abseil Authors.
// //
// Licensed under the Apache License, Version 2.0 (the "License"); // Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License. // you may not use this file except in compliance with the License.
...@@ -910,6 +910,11 @@ struct PerformVisitation { ...@@ -910,6 +910,11 @@ struct PerformVisitation {
template <std::size_t... TupIs, std::size_t... Is> template <std::size_t... TupIs, std::size_t... Is>
constexpr ReturnType Run(std::false_type /*has_valueless*/, constexpr ReturnType Run(std::false_type /*has_valueless*/,
index_sequence<TupIs...>, SizeT<Is>...) const { index_sequence<TupIs...>, SizeT<Is>...) const {
static_assert(
std::is_same<ReturnType,
absl::result_of_t<Op(VariantAccessResult<
Is, QualifiedVariants>...)>>::value,
"All visitation overloads must have the same return type.");
return absl::base_internal::Invoke( return absl::base_internal::Invoke(
absl::forward<Op>(op), absl::forward<Op>(op),
VariantCoreAccess::Access<Is>( VariantCoreAccess::Access<Is>(
......
absl/types/optional_exception_safety_test.cc
...@@ -43,7 +43,7 @@ bool ValueThrowsBadOptionalAccess(const OptionalT& optional) try { ...@@ -43,7 +43,7 @@ bool ValueThrowsBadOptionalAccess(const OptionalT& optional) try {
} }
template <typename OptionalT> template <typename OptionalT>
AssertionResult CheckInvariants(OptionalT* optional_ptr) { AssertionResult OptionalInvariants(OptionalT* optional_ptr) {
// Check the current state post-throw for validity // Check the current state post-throw for validity
auto& optional = *optional_ptr; auto& optional = *optional_ptr;
...@@ -123,8 +123,8 @@ TEST(OptionalExceptionSafety, NothrowConstructors) { ...@@ -123,8 +123,8 @@ TEST(OptionalExceptionSafety, NothrowConstructors) {
TEST(OptionalExceptionSafety, Emplace) { TEST(OptionalExceptionSafety, Emplace) {
// Test the basic guarantee plus test the result of optional::has_value() // Test the basic guarantee plus test the result of optional::has_value()
// is false in all cases // is false in all cases
auto disengaged_test = MakeExceptionSafetyTester().WithInvariants( auto disengaged_test = MakeExceptionSafetyTester().WithContracts(
CheckInvariants<Optional>, CheckDisengaged<Optional>); OptionalInvariants<Optional>, CheckDisengaged<Optional>);
auto disengaged_test_empty = disengaged_test.WithInitialValue(Optional()); auto disengaged_test_empty = disengaged_test.WithInitialValue(Optional());
auto disengaged_test_nonempty = auto disengaged_test_nonempty =
disengaged_test.WithInitialValue(Optional(kInitialInteger)); disengaged_test.WithInitialValue(Optional(kInitialInteger));
...@@ -147,11 +147,11 @@ TEST(OptionalExceptionSafety, EverythingThrowsSwap) { ...@@ -147,11 +147,11 @@ TEST(OptionalExceptionSafety, EverythingThrowsSwap) {
// Test the basic guarantee plus test the result of optional::has_value() // Test the basic guarantee plus test the result of optional::has_value()
// remains the same // remains the same
auto test = auto test =
MakeExceptionSafetyTester().WithInvariants(CheckInvariants<Optional>); MakeExceptionSafetyTester().WithContracts(OptionalInvariants<Optional>);
auto disengaged_test_empty = test.WithInitialValue(Optional()) auto disengaged_test_empty = test.WithInitialValue(Optional())
.WithInvariants(CheckDisengaged<Optional>); .WithContracts(CheckDisengaged<Optional>);
auto engaged_test_nonempty = test.WithInitialValue(Optional(kInitialInteger)) auto engaged_test_nonempty = test.WithInitialValue(Optional(kInitialInteger))
.WithInvariants(CheckEngaged<Optional>); .WithContracts(CheckEngaged<Optional>);
auto swap_empty = [](Optional* optional_ptr) { auto swap_empty = [](Optional* optional_ptr) {
auto empty = Optional(); auto empty = Optional();
...@@ -192,11 +192,11 @@ TEST(OptionalExceptionSafety, CopyAssign) { ...@@ -192,11 +192,11 @@ TEST(OptionalExceptionSafety, CopyAssign) {
// Test the basic guarantee plus test the result of optional::has_value() // Test the basic guarantee plus test the result of optional::has_value()
// remains the same // remains the same
auto test = auto test =
MakeExceptionSafetyTester().WithInvariants(CheckInvariants<Optional>); MakeExceptionSafetyTester().WithContracts(OptionalInvariants<Optional>);
auto disengaged_test_empty = test.WithInitialValue(Optional()) auto disengaged_test_empty = test.WithInitialValue(Optional())
.WithInvariants(CheckDisengaged<Optional>); .WithContracts(CheckDisengaged<Optional>);
auto engaged_test_nonempty = test.WithInitialValue(Optional(kInitialInteger)) auto engaged_test_nonempty = test.WithInitialValue(Optional(kInitialInteger))
.WithInvariants(CheckEngaged<Optional>); .WithContracts(CheckEngaged<Optional>);
auto copyassign_nonempty = [](Optional* optional_ptr) { auto copyassign_nonempty = [](Optional* optional_ptr) {
auto nonempty = auto nonempty =
...@@ -218,11 +218,11 @@ TEST(OptionalExceptionSafety, MoveAssign) { ...@@ -218,11 +218,11 @@ TEST(OptionalExceptionSafety, MoveAssign) {
// Test the basic guarantee plus test the result of optional::has_value() // Test the basic guarantee plus test the result of optional::has_value()
// remains the same // remains the same
auto test = auto test =
MakeExceptionSafetyTester().WithInvariants(CheckInvariants<Optional>); MakeExceptionSafetyTester().WithContracts(OptionalInvariants<Optional>);
auto disengaged_test_empty = test.WithInitialValue(Optional()) auto disengaged_test_empty = test.WithInitialValue(Optional())
.WithInvariants(CheckDisengaged<Optional>); .WithContracts(CheckDisengaged<Optional>);
auto engaged_test_nonempty = test.WithInitialValue(Optional(kInitialInteger)) auto engaged_test_nonempty = test.WithInitialValue(Optional(kInitialInteger))
.WithInvariants(CheckEngaged<Optional>); .WithContracts(CheckEngaged<Optional>);
auto moveassign_empty = [](Optional* optional_ptr) { auto moveassign_empty = [](Optional* optional_ptr) {
auto empty = Optional(); auto empty = Optional();
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment