Export of internal Abseil changes

--
034c30a00c64d93b9fcbc9d99a0a33801544d741 by Gennadiy Rozental <rogeeff@google.com>:

Split private handle interfaces accessor into a separate target with private visibility.

PiperOrigin-RevId: 310391488

--
6f6ca869309b17900b90849e08488ce7f7b0193a by Derek Mauro <dmauro@google.com>:

Remove __CLANG_SUPPORT_DYN_ANNOTATION__, which is a symbol defined by us
to be true in all builds

PiperOrigin-RevId: 310385325

--
ed5c1880c86973c000e826a3006b38e53ab3ed52 by Samuel Benzaquen <sbenza@google.com>:

Add tests to exercise extreme width and precision, and fix the overflows from
it.

PiperOrigin-RevId: 310224957
GitOrigin-RevId: 034c30a00c64d93b9fcbc9d99a0a33801544d741
Change-Id: I6c89a3c89ae92fa617c696044148ce9a79bcdda8
pull/682/head
Abseil Team 5 years ago committed by vslashg
parent bd317cae3b
commit a35ef8a62c
  1. 1
      absl/base/BUILD.bazel
  2. 2
      absl/base/CMakeLists.txt
  3. 5
      absl/base/dynamic_annotations.h
  4. 23
      absl/flags/BUILD.bazel
  5. 23
      absl/flags/CMakeLists.txt
  6. 27
      absl/flags/internal/commandlineflag.cc
  7. 31
      absl/flags/internal/commandlineflag.h
  8. 31
      absl/flags/internal/commandlineflag_test.cc
  9. 1
      absl/flags/internal/flag.h
  10. 52
      absl/flags/internal/private_handle_accessor.cc
  11. 52
      absl/flags/internal/private_handle_accessor.h
  12. 7
      absl/flags/internal/registry.cc
  13. 5
      absl/flags/internal/type_erased.cc
  14. 1
      absl/flags/internal/usage.cc
  15. 5
      absl/flags/parse.cc
  16. 25
      absl/strings/internal/str_format/convert_test.cc
  17. 20
      absl/strings/internal/str_format/float_conversion.cc

@ -118,7 +118,6 @@ cc_library(
srcs = ["dynamic_annotations.cc"], srcs = ["dynamic_annotations.cc"],
hdrs = ["dynamic_annotations.h"], hdrs = ["dynamic_annotations.h"],
copts = ABSL_DEFAULT_COPTS, copts = ABSL_DEFAULT_COPTS,
defines = ["__CLANG_SUPPORT_DYN_ANNOTATION__"],
linkopts = ABSL_DEFAULT_LINKOPTS, linkopts = ABSL_DEFAULT_LINKOPTS,
) )

@ -108,8 +108,6 @@ absl_cc_library(
"dynamic_annotations.cc" "dynamic_annotations.cc"
COPTS COPTS
${ABSL_DEFAULT_COPTS} ${ABSL_DEFAULT_COPTS}
DEFINES
"__CLANG_SUPPORT_DYN_ANNOTATION__"
PUBLIC PUBLIC
) )

@ -140,10 +140,7 @@
#define ANNOTATE_MEMORY_IS_UNINITIALIZED(address, size) /* empty */ #define ANNOTATE_MEMORY_IS_UNINITIALIZED(address, size) /* empty */
#endif /* DYNAMIC_ANNOTATIONS_ENABLED || MEMORY_SANITIZER */ #endif /* DYNAMIC_ANNOTATIONS_ENABLED || MEMORY_SANITIZER */
/* TODO(delesley) -- Replace __CLANG_SUPPORT_DYN_ANNOTATION__ with the #if defined(__clang__) && !defined(SWIG)
appropriate feature ID. */
#if defined(__clang__) && (!defined(SWIG)) \
&& defined(__CLANG_SUPPORT_DYN_ANNOTATION__)
#if DYNAMIC_ANNOTATIONS_ENABLED == 0 #if DYNAMIC_ANNOTATIONS_ENABLED == 0
#define ANNOTALYSIS_ENABLED #define ANNOTALYSIS_ENABLED

@ -40,6 +40,7 @@ cc_library(
deps = [ deps = [
":config", ":config",
":handle", ":handle",
":marshalling",
":registry", ":registry",
"//absl/base", "//absl/base",
"//absl/base:config", "//absl/base:config",
@ -143,8 +144,6 @@ cc_library(
"//absl/flags:__pkg__", "//absl/flags:__pkg__",
], ],
deps = [ deps = [
":config",
":marshalling",
"//absl/base:config", "//absl/base:config",
"//absl/base:core_headers", "//absl/base:core_headers",
"//absl/base:fast_type_id", "//absl/base:fast_type_id",
@ -153,6 +152,22 @@ cc_library(
], ],
) )
cc_library(
name = "private_handle_accessor",
srcs = [
"internal/private_handle_accessor.cc",
],
hdrs = [
"internal/private_handle_accessor.h",
],
copts = ABSL_DEFAULT_COPTS,
linkopts = ABSL_DEFAULT_LINKOPTS,
visibility = [
"//absl/flags:__pkg__",
],
deps = [":handle"],
)
cc_library( cc_library(
name = "registry", name = "registry",
srcs = [ srcs = [
@ -171,6 +186,7 @@ cc_library(
deps = [ deps = [
":config", ":config",
":handle", ":handle",
":private_handle_accessor",
"//absl/base:config", "//absl/base:config",
"//absl/base:core_headers", "//absl/base:core_headers",
"//absl/base:raw_logging_internal", "//absl/base:raw_logging_internal",
@ -222,6 +238,7 @@ cc_library(
":flag_internal", ":flag_internal",
":handle", ":handle",
":path_util", ":path_util",
":private_handle_accessor",
":program_name", ":program_name",
":registry", ":registry",
"//absl/base:config", "//absl/base:config",
@ -263,6 +280,7 @@ cc_library(
":flag", ":flag",
":flag_internal", ":flag_internal",
":handle", ":handle",
":private_handle_accessor",
":program_name", ":program_name",
":registry", ":registry",
":usage", ":usage",
@ -289,6 +307,7 @@ cc_test(
":config", ":config",
":flag", ":flag",
":handle", ":handle",
":private_handle_accessor",
":registry", ":registry",
"//absl/memory", "//absl/memory",
"//absl/strings", "//absl/strings",

@ -31,6 +31,7 @@ absl_cc_library(
absl::config absl::config
absl::flags_config absl::flags_config
absl::flags_handle absl::flags_handle
absl::flags_marshalling
absl::flags_registry absl::flags_registry
absl::synchronization absl::synchronization
absl::meta absl::meta
@ -129,8 +130,6 @@ absl_cc_library(
DEPS DEPS
absl::config absl::config
absl::fast_type_id absl::fast_type_id
absl::flags_config
absl::flags_marshalling
absl::core_headers absl::core_headers
absl::optional absl::optional
absl::raw_logging_internal absl::raw_logging_internal
@ -138,6 +137,22 @@ absl_cc_library(
absl::synchronization absl::synchronization
) )
# Internal-only target, do not depend on directly.
absl_cc_library(
NAME
flags_private_handle_accessor
SRCS
"internal/private_handle_accessor.cc"
HDRS
"internal/private_handle_accessor.h"
COPTS
${ABSL_DEFAULT_COPTS}
LINKOPTS
${ABSL_DEFAULT_LINKOPTS}
DEPS
absl::flags_handle
)
# Internal-only target, do not depend on directly. # Internal-only target, do not depend on directly.
absl_cc_library( absl_cc_library(
NAME NAME
@ -156,6 +171,7 @@ absl_cc_library(
absl::config absl::config
absl::flags_config absl::flags_config
absl::flags_handle absl::flags_handle
absl::flags_private_handle_accessor
absl::core_headers absl::core_headers
absl::raw_logging_internal absl::raw_logging_internal
absl::strings absl::strings
@ -203,6 +219,7 @@ absl_cc_library(
absl::flags_config absl::flags_config
absl::flags absl::flags
absl::flags_handle absl::flags_handle
absl::flags_private_handle_accessor
absl::flags_internal absl::flags_internal
absl::flags_path_util absl::flags_path_util
absl::flags_program_name absl::flags_program_name
@ -248,6 +265,7 @@ absl_cc_library(
absl::flags_config absl::flags_config
absl::flags absl::flags
absl::flags_handle absl::flags_handle
absl::flags_private_handle_accessor
absl::flags_internal absl::flags_internal
absl::flags_program_name absl::flags_program_name
absl::flags_registry absl::flags_registry
@ -270,6 +288,7 @@ absl_cc_test(
absl::flags absl::flags
absl::flags_config absl::flags_config
absl::flags_handle absl::flags_handle
absl::flags_private_handle_accessor
absl::flags_registry absl::flags_registry
absl::memory absl::memory
absl::strings absl::strings

@ -28,33 +28,6 @@ bool CommandLineFlag::ParseFrom(absl::string_view value, std::string* error) {
flags_internal::kProgrammaticChange, error); flags_internal::kProgrammaticChange, error);
} }
FlagFastTypeId PrivateHandleInterface::TypeId(const CommandLineFlag& flag) {
return flag.TypeId();
}
std::unique_ptr<FlagStateInterface> PrivateHandleInterface::SaveState(
CommandLineFlag* flag) {
return flag->SaveState();
}
bool PrivateHandleInterface::ValidateInputValue(const CommandLineFlag& flag,
absl::string_view value) {
return flag.ValidateInputValue(value);
}
void PrivateHandleInterface::CheckDefaultValueParsingRoundtrip(
const CommandLineFlag& flag) {
flag.CheckDefaultValueParsingRoundtrip();
}
bool PrivateHandleInterface::ParseFrom(CommandLineFlag* flag,
absl::string_view value,
flags_internal::FlagSettingMode set_mode,
flags_internal::ValueSource source,
std::string* error) {
return flag->ParseFrom(value, set_mode, source, error);
}
} // namespace flags_internal } // namespace flags_internal
ABSL_NAMESPACE_END ABSL_NAMESPACE_END
} // namespace absl } // namespace absl

@ -16,18 +16,12 @@
#ifndef ABSL_FLAGS_INTERNAL_COMMANDLINEFLAG_H_ #ifndef ABSL_FLAGS_INTERNAL_COMMANDLINEFLAG_H_
#define ABSL_FLAGS_INTERNAL_COMMANDLINEFLAG_H_ #define ABSL_FLAGS_INTERNAL_COMMANDLINEFLAG_H_
#include <stddef.h>
#include <stdint.h>
#include <memory> #include <memory>
#include <string> #include <string>
#include <typeinfo>
#include "absl/base/config.h" #include "absl/base/config.h"
#include "absl/base/internal/fast_type_id.h" #include "absl/base/internal/fast_type_id.h"
#include "absl/base/macros.h" #include "absl/base/macros.h"
#include "absl/flags/config.h"
#include "absl/flags/marshalling.h"
#include "absl/strings/string_view.h" #include "absl/strings/string_view.h"
#include "absl/types/optional.h" #include "absl/types/optional.h"
@ -147,7 +141,7 @@ class CommandLineFlag {
~CommandLineFlag() = default; ~CommandLineFlag() = default;
private: private:
friend class PrivateHandleInterface; friend class PrivateHandleAccessor;
// Sets the value of the flag based on specified string `value`. If the flag // Sets the value of the flag based on specified string `value`. If the flag
// was successfully set to new value, it returns true. Otherwise, sets `error` // was successfully set to new value, it returns true. Otherwise, sets `error`
@ -181,29 +175,6 @@ class CommandLineFlag {
virtual void CheckDefaultValueParsingRoundtrip() const = 0; virtual void CheckDefaultValueParsingRoundtrip() const = 0;
}; };
// This class serves as a trampoline to access private methods of
// CommandLineFlag. This class is intended for use exclusively internally inside
// of the Abseil Flags implementation
class PrivateHandleInterface {
public:
// Access to CommandLineFlag::TypeId.
static FlagFastTypeId TypeId(const CommandLineFlag& flag);
// Access to CommandLineFlag::SaveState.
static std::unique_ptr<FlagStateInterface> SaveState(CommandLineFlag* flag);
// Access to CommandLineFlag::ValidateInputValue.
static bool ValidateInputValue(const CommandLineFlag& flag,
absl::string_view value);
// Access to CommandLineFlag::CheckDefaultValueParsingRoundtrip.
static void CheckDefaultValueParsingRoundtrip(const CommandLineFlag& flag);
static bool ParseFrom(CommandLineFlag* flag, absl::string_view value,
flags_internal::FlagSettingMode set_mode,
flags_internal::ValueSource source, std::string* error);
};
// This macro is the "source of truth" for the list of supported flag built-in // This macro is the "source of truth" for the list of supported flag built-in
// types. // types.
#define ABSL_FLAGS_INTERNAL_BUILTIN_TYPES(A) \ #define ABSL_FLAGS_INTERNAL_BUILTIN_TYPES(A) \

@ -20,6 +20,7 @@
#include "gtest/gtest.h" #include "gtest/gtest.h"
#include "absl/flags/flag.h" #include "absl/flags/flag.h"
#include "absl/flags/internal/private_handle_accessor.h"
#include "absl/flags/internal/registry.h" #include "absl/flags/internal/registry.h"
#include "absl/flags/usage_config.h" #include "absl/flags/usage_config.h"
#include "absl/memory/memory.h" #include "absl/memory/memory.h"
@ -122,52 +123,52 @@ TEST_F(CommandLineFlagTest, TestParseFromCurrentValue) {
auto* flag_01 = flags::FindCommandLineFlag("int_flag"); auto* flag_01 = flags::FindCommandLineFlag("int_flag");
EXPECT_FALSE(flag_01->IsSpecifiedOnCommandLine()); EXPECT_FALSE(flag_01->IsSpecifiedOnCommandLine());
EXPECT_TRUE(flags::PrivateHandleInterface::ParseFrom( EXPECT_TRUE(flags::PrivateHandleAccessor::ParseFrom(
flag_01, "11", flags::SET_FLAGS_VALUE, flags::kProgrammaticChange, &err)); flag_01, "11", flags::SET_FLAGS_VALUE, flags::kProgrammaticChange, &err));
EXPECT_EQ(absl::GetFlag(FLAGS_int_flag), 11); EXPECT_EQ(absl::GetFlag(FLAGS_int_flag), 11);
EXPECT_FALSE(flag_01->IsSpecifiedOnCommandLine()); EXPECT_FALSE(flag_01->IsSpecifiedOnCommandLine());
EXPECT_TRUE(flags::PrivateHandleInterface::ParseFrom( EXPECT_TRUE(flags::PrivateHandleAccessor::ParseFrom(
flag_01, "-123", flags::SET_FLAGS_VALUE, flags::kProgrammaticChange, flag_01, "-123", flags::SET_FLAGS_VALUE, flags::kProgrammaticChange,
&err)); &err));
EXPECT_EQ(absl::GetFlag(FLAGS_int_flag), -123); EXPECT_EQ(absl::GetFlag(FLAGS_int_flag), -123);
EXPECT_FALSE(flag_01->IsSpecifiedOnCommandLine()); EXPECT_FALSE(flag_01->IsSpecifiedOnCommandLine());
EXPECT_TRUE(!flags::PrivateHandleInterface::ParseFrom( EXPECT_TRUE(!flags::PrivateHandleAccessor::ParseFrom(
flag_01, "xyz", flags::SET_FLAGS_VALUE, flags::kProgrammaticChange, flag_01, "xyz", flags::SET_FLAGS_VALUE, flags::kProgrammaticChange,
&err)); &err));
EXPECT_EQ(absl::GetFlag(FLAGS_int_flag), -123); EXPECT_EQ(absl::GetFlag(FLAGS_int_flag), -123);
EXPECT_EQ(err, "Illegal value 'xyz' specified for flag 'int_flag'"); EXPECT_EQ(err, "Illegal value 'xyz' specified for flag 'int_flag'");
EXPECT_FALSE(flag_01->IsSpecifiedOnCommandLine()); EXPECT_FALSE(flag_01->IsSpecifiedOnCommandLine());
EXPECT_TRUE(!flags::PrivateHandleInterface::ParseFrom( EXPECT_TRUE(!flags::PrivateHandleAccessor::ParseFrom(
flag_01, "A1", flags::SET_FLAGS_VALUE, flags::kProgrammaticChange, &err)); flag_01, "A1", flags::SET_FLAGS_VALUE, flags::kProgrammaticChange, &err));
EXPECT_EQ(absl::GetFlag(FLAGS_int_flag), -123); EXPECT_EQ(absl::GetFlag(FLAGS_int_flag), -123);
EXPECT_EQ(err, "Illegal value 'A1' specified for flag 'int_flag'"); EXPECT_EQ(err, "Illegal value 'A1' specified for flag 'int_flag'");
EXPECT_FALSE(flag_01->IsSpecifiedOnCommandLine()); EXPECT_FALSE(flag_01->IsSpecifiedOnCommandLine());
EXPECT_TRUE(flags::PrivateHandleInterface::ParseFrom( EXPECT_TRUE(flags::PrivateHandleAccessor::ParseFrom(
flag_01, "0x10", flags::SET_FLAGS_VALUE, flags::kProgrammaticChange, flag_01, "0x10", flags::SET_FLAGS_VALUE, flags::kProgrammaticChange,
&err)); &err));
EXPECT_EQ(absl::GetFlag(FLAGS_int_flag), 16); EXPECT_EQ(absl::GetFlag(FLAGS_int_flag), 16);
EXPECT_FALSE(flag_01->IsSpecifiedOnCommandLine()); EXPECT_FALSE(flag_01->IsSpecifiedOnCommandLine());
EXPECT_TRUE(flags::PrivateHandleInterface::ParseFrom( EXPECT_TRUE(flags::PrivateHandleAccessor::ParseFrom(
flag_01, "011", flags::SET_FLAGS_VALUE, flags::kCommandLine, &err)); flag_01, "011", flags::SET_FLAGS_VALUE, flags::kCommandLine, &err));
EXPECT_EQ(absl::GetFlag(FLAGS_int_flag), 11); EXPECT_EQ(absl::GetFlag(FLAGS_int_flag), 11);
EXPECT_TRUE(flag_01->IsSpecifiedOnCommandLine()); EXPECT_TRUE(flag_01->IsSpecifiedOnCommandLine());
EXPECT_TRUE(!flags::PrivateHandleInterface::ParseFrom( EXPECT_TRUE(!flags::PrivateHandleAccessor::ParseFrom(
flag_01, "", flags::SET_FLAGS_VALUE, flags::kProgrammaticChange, &err)); flag_01, "", flags::SET_FLAGS_VALUE, flags::kProgrammaticChange, &err));
EXPECT_EQ(err, "Illegal value '' specified for flag 'int_flag'"); EXPECT_EQ(err, "Illegal value '' specified for flag 'int_flag'");
auto* flag_02 = flags::FindCommandLineFlag("string_flag"); auto* flag_02 = flags::FindCommandLineFlag("string_flag");
EXPECT_TRUE(flags::PrivateHandleInterface::ParseFrom( EXPECT_TRUE(flags::PrivateHandleAccessor::ParseFrom(
flag_02, "xyz", flags::SET_FLAGS_VALUE, flags::kProgrammaticChange, flag_02, "xyz", flags::SET_FLAGS_VALUE, flags::kProgrammaticChange,
&err)); &err));
EXPECT_EQ(absl::GetFlag(FLAGS_string_flag), "xyz"); EXPECT_EQ(absl::GetFlag(FLAGS_string_flag), "xyz");
EXPECT_TRUE(flags::PrivateHandleInterface::ParseFrom( EXPECT_TRUE(flags::PrivateHandleAccessor::ParseFrom(
flag_02, "", flags::SET_FLAGS_VALUE, flags::kProgrammaticChange, &err)); flag_02, "", flags::SET_FLAGS_VALUE, flags::kProgrammaticChange, &err));
EXPECT_EQ(absl::GetFlag(FLAGS_string_flag), ""); EXPECT_EQ(absl::GetFlag(FLAGS_string_flag), "");
} }
@ -179,14 +180,14 @@ TEST_F(CommandLineFlagTest, TestParseFromDefaultValue) {
auto* flag_01 = flags::FindCommandLineFlag("int_flag"); auto* flag_01 = flags::FindCommandLineFlag("int_flag");
EXPECT_TRUE(flags::PrivateHandleInterface::ParseFrom( EXPECT_TRUE(flags::PrivateHandleAccessor::ParseFrom(
flag_01, "111", flags::SET_FLAGS_DEFAULT, flags::kProgrammaticChange, flag_01, "111", flags::SET_FLAGS_DEFAULT, flags::kProgrammaticChange,
&err)); &err));
EXPECT_EQ(flag_01->DefaultValue(), "111"); EXPECT_EQ(flag_01->DefaultValue(), "111");
auto* flag_02 = flags::FindCommandLineFlag("string_flag"); auto* flag_02 = flags::FindCommandLineFlag("string_flag");
EXPECT_TRUE(flags::PrivateHandleInterface::ParseFrom( EXPECT_TRUE(flags::PrivateHandleAccessor::ParseFrom(
flag_02, "abc", flags::SET_FLAGS_DEFAULT, flags::kProgrammaticChange, flag_02, "abc", flags::SET_FLAGS_DEFAULT, flags::kProgrammaticChange,
&err)); &err));
EXPECT_EQ(flag_02->DefaultValue(), "abc"); EXPECT_EQ(flag_02->DefaultValue(), "abc");
@ -199,24 +200,24 @@ TEST_F(CommandLineFlagTest, TestParseFromIfDefault) {
auto* flag_01 = flags::FindCommandLineFlag("int_flag"); auto* flag_01 = flags::FindCommandLineFlag("int_flag");
EXPECT_TRUE(flags::PrivateHandleInterface::ParseFrom( EXPECT_TRUE(flags::PrivateHandleAccessor::ParseFrom(
flag_01, "22", flags::SET_FLAG_IF_DEFAULT, flags::kProgrammaticChange, flag_01, "22", flags::SET_FLAG_IF_DEFAULT, flags::kProgrammaticChange,
&err)) &err))
<< err; << err;
EXPECT_EQ(absl::GetFlag(FLAGS_int_flag), 22); EXPECT_EQ(absl::GetFlag(FLAGS_int_flag), 22);
EXPECT_TRUE(flags::PrivateHandleInterface::ParseFrom( EXPECT_TRUE(flags::PrivateHandleAccessor::ParseFrom(
flag_01, "33", flags::SET_FLAG_IF_DEFAULT, flags::kProgrammaticChange, flag_01, "33", flags::SET_FLAG_IF_DEFAULT, flags::kProgrammaticChange,
&err)); &err));
EXPECT_EQ(absl::GetFlag(FLAGS_int_flag), 22); EXPECT_EQ(absl::GetFlag(FLAGS_int_flag), 22);
// EXPECT_EQ(err, "ERROR: int_flag is already set to 22"); // EXPECT_EQ(err, "ERROR: int_flag is already set to 22");
// Reset back to default value // Reset back to default value
EXPECT_TRUE(flags::PrivateHandleInterface::ParseFrom( EXPECT_TRUE(flags::PrivateHandleAccessor::ParseFrom(
flag_01, "201", flags::SET_FLAGS_VALUE, flags::kProgrammaticChange, flag_01, "201", flags::SET_FLAGS_VALUE, flags::kProgrammaticChange,
&err)); &err));
EXPECT_TRUE(flags::PrivateHandleInterface::ParseFrom( EXPECT_TRUE(flags::PrivateHandleAccessor::ParseFrom(
flag_01, "33", flags::SET_FLAG_IF_DEFAULT, flags::kProgrammaticChange, flag_01, "33", flags::SET_FLAG_IF_DEFAULT, flags::kProgrammaticChange,
&err)); &err));
EXPECT_EQ(absl::GetFlag(FLAGS_int_flag), 201); EXPECT_EQ(absl::GetFlag(FLAGS_int_flag), 201);

@ -31,6 +31,7 @@
#include "absl/flags/config.h" #include "absl/flags/config.h"
#include "absl/flags/internal/commandlineflag.h" #include "absl/flags/internal/commandlineflag.h"
#include "absl/flags/internal/registry.h" #include "absl/flags/internal/registry.h"
#include "absl/flags/marshalling.h"
#include "absl/memory/memory.h" #include "absl/memory/memory.h"
#include "absl/meta/type_traits.h" #include "absl/meta/type_traits.h"
#include "absl/strings/str_cat.h" #include "absl/strings/str_cat.h"

@ -0,0 +1,52 @@
//
// Copyright 2020 The Abseil Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#include "absl/flags/internal/private_handle_accessor.h"
namespace absl {
ABSL_NAMESPACE_BEGIN
namespace flags_internal {
FlagFastTypeId PrivateHandleAccessor::TypeId(const CommandLineFlag& flag) {
return flag.TypeId();
}
std::unique_ptr<FlagStateInterface> PrivateHandleAccessor::SaveState(
CommandLineFlag* flag) {
return flag->SaveState();
}
bool PrivateHandleAccessor::ValidateInputValue(const CommandLineFlag& flag,
absl::string_view value) {
return flag.ValidateInputValue(value);
}
void PrivateHandleAccessor::CheckDefaultValueParsingRoundtrip(
const CommandLineFlag& flag) {
flag.CheckDefaultValueParsingRoundtrip();
}
bool PrivateHandleAccessor::ParseFrom(CommandLineFlag* flag,
absl::string_view value,
flags_internal::FlagSettingMode set_mode,
flags_internal::ValueSource source,
std::string* error) {
return flag->ParseFrom(value, set_mode, source, error);
}
} // namespace flags_internal
ABSL_NAMESPACE_END
} // namespace absl

@ -0,0 +1,52 @@
//
// Copyright 2020 The Abseil Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#ifndef ABSL_FLAGS_INTERNAL_PRIVATE_HANDLE_ACCESSOR_H_
#define ABSL_FLAGS_INTERNAL_PRIVATE_HANDLE_ACCESSOR_H_
#include "absl/flags/internal/commandlineflag.h"
namespace absl {
ABSL_NAMESPACE_BEGIN
namespace flags_internal {
// This class serves as a trampoline to access private methods of
// CommandLineFlag. This class is intended for use exclusively internally inside
// of the Abseil Flags implementation.
class PrivateHandleAccessor {
public:
// Access to CommandLineFlag::TypeId.
static FlagFastTypeId TypeId(const CommandLineFlag& flag);
// Access to CommandLineFlag::SaveState.
static std::unique_ptr<FlagStateInterface> SaveState(CommandLineFlag* flag);
// Access to CommandLineFlag::ValidateInputValue.
static bool ValidateInputValue(const CommandLineFlag& flag,
absl::string_view value);
// Access to CommandLineFlag::CheckDefaultValueParsingRoundtrip.
static void CheckDefaultValueParsingRoundtrip(const CommandLineFlag& flag);
static bool ParseFrom(CommandLineFlag* flag, absl::string_view value,
flags_internal::FlagSettingMode set_mode,
flags_internal::ValueSource source, std::string* error);
};
} // namespace flags_internal
ABSL_NAMESPACE_END
} // namespace absl
#endif // ABSL_FLAGS_INTERNAL_PRIVATE_HANDLE_ACCESSOR_H_

@ -29,6 +29,7 @@
#include "absl/base/internal/raw_logging.h" #include "absl/base/internal/raw_logging.h"
#include "absl/base/thread_annotations.h" #include "absl/base/thread_annotations.h"
#include "absl/flags/internal/commandlineflag.h" #include "absl/flags/internal/commandlineflag.h"
#include "absl/flags/internal/private_handle_accessor.h"
#include "absl/flags/usage_config.h" #include "absl/flags/usage_config.h"
#include "absl/strings/str_cat.h" #include "absl/strings/str_cat.h"
#include "absl/strings/string_view.h" #include "absl/strings/string_view.h"
@ -127,8 +128,8 @@ void FlagRegistry::RegisterFlag(CommandLineFlag* flag) {
(flag->IsRetired() ? old_flag->Filename() : flag->Filename()), (flag->IsRetired() ? old_flag->Filename() : flag->Filename()),
"'."), "'."),
true); true);
} else if (flags_internal::PrivateHandleInterface::TypeId(*flag) != } else if (flags_internal::PrivateHandleAccessor::TypeId(*flag) !=
flags_internal::PrivateHandleInterface::TypeId(*old_flag)) { flags_internal::PrivateHandleAccessor::TypeId(*old_flag)) {
flags_internal::ReportUsageError( flags_internal::ReportUsageError(
absl::StrCat("Flag '", flag->Name(), absl::StrCat("Flag '", flag->Name(),
"' was defined more than once but with " "' was defined more than once but with "
@ -206,7 +207,7 @@ class FlagSaverImpl {
assert(backup_registry_.empty()); // call only once! assert(backup_registry_.empty()); // call only once!
flags_internal::ForEachFlag([&](flags_internal::CommandLineFlag* flag) { flags_internal::ForEachFlag([&](flags_internal::CommandLineFlag* flag) {
if (auto flag_state = if (auto flag_state =
flags_internal::PrivateHandleInterface::SaveState(flag)) { flags_internal::PrivateHandleAccessor::SaveState(flag)) {
backup_registry_.emplace_back(std::move(flag_state)); backup_registry_.emplace_back(std::move(flag_state));
} }
}); });

@ -22,6 +22,7 @@
#include "absl/base/config.h" #include "absl/base/config.h"
#include "absl/base/internal/raw_logging.h" #include "absl/base/internal/raw_logging.h"
#include "absl/flags/internal/commandlineflag.h" #include "absl/flags/internal/commandlineflag.h"
#include "absl/flags/internal/private_handle_accessor.h"
#include "absl/flags/internal/registry.h" #include "absl/flags/internal/registry.h"
#include "absl/flags/usage_config.h" #include "absl/flags/usage_config.h"
#include "absl/strings/string_view.h" #include "absl/strings/string_view.h"
@ -56,7 +57,7 @@ bool SetCommandLineOptionWithMode(absl::string_view name,
if (!flag || flag->IsRetired()) return false; if (!flag || flag->IsRetired()) return false;
std::string error; std::string error;
if (!flags_internal::PrivateHandleInterface::ParseFrom( if (!flags_internal::PrivateHandleAccessor::ParseFrom(
flag, value, set_mode, kProgrammaticChange, &error)) { flag, value, set_mode, kProgrammaticChange, &error)) {
// Errors here are all of the form: the provided name was a recognized // Errors here are all of the form: the provided name was a recognized
// flag, but the value was invalid (bad type, or validation failed). // flag, but the value was invalid (bad type, or validation failed).
@ -74,7 +75,7 @@ bool IsValidFlagValue(absl::string_view name, absl::string_view value) {
return flag != nullptr && return flag != nullptr &&
(flag->IsRetired() || (flag->IsRetired() ||
flags_internal::PrivateHandleInterface::ValidateInputValue(*flag, flags_internal::PrivateHandleAccessor::ValidateInputValue(*flag,
value)); value));
} }

@ -27,6 +27,7 @@
#include "absl/flags/internal/commandlineflag.h" #include "absl/flags/internal/commandlineflag.h"
#include "absl/flags/internal/flag.h" #include "absl/flags/internal/flag.h"
#include "absl/flags/internal/path_util.h" #include "absl/flags/internal/path_util.h"
#include "absl/flags/internal/private_handle_accessor.h"
#include "absl/flags/internal/program_name.h" #include "absl/flags/internal/program_name.h"
#include "absl/flags/internal/registry.h" #include "absl/flags/internal/registry.h"
#include "absl/flags/usage_config.h" #include "absl/flags/usage_config.h"

@ -39,6 +39,7 @@
#include "absl/flags/internal/commandlineflag.h" #include "absl/flags/internal/commandlineflag.h"
#include "absl/flags/internal/flag.h" #include "absl/flags/internal/flag.h"
#include "absl/flags/internal/parse.h" #include "absl/flags/internal/parse.h"
#include "absl/flags/internal/private_handle_accessor.h"
#include "absl/flags/internal/program_name.h" #include "absl/flags/internal/program_name.h"
#include "absl/flags/internal/registry.h" #include "absl/flags/internal/registry.h"
#include "absl/flags/internal/usage.h" #include "absl/flags/internal/usage.h"
@ -298,7 +299,7 @@ void CheckDefaultValuesParsingRoundtrip() {
ABSL_FLAGS_INTERNAL_BUILTIN_TYPES(IGNORE_TYPE) ABSL_FLAGS_INTERNAL_BUILTIN_TYPES(IGNORE_TYPE)
#undef IGNORE_TYPE #undef IGNORE_TYPE
flags_internal::PrivateHandleInterface::CheckDefaultValueParsingRoundtrip( flags_internal::PrivateHandleAccessor::CheckDefaultValueParsingRoundtrip(
*flag); *flag);
}); });
#endif #endif
@ -697,7 +698,7 @@ std::vector<char*> ParseCommandLineImpl(int argc, char* argv[],
if (flag->IsRetired()) continue; if (flag->IsRetired()) continue;
std::string error; std::string error;
if (!flags_internal::PrivateHandleInterface::ParseFrom( if (!flags_internal::PrivateHandleAccessor::ParseFrom(
flag, value, SET_FLAGS_VALUE, kCommandLine, &error)) { flag, value, SET_FLAGS_VALUE, kCommandLine, &error)) {
flags_internal::ReportUsageError(error, true); flags_internal::ReportUsageError(error, true);
success = false; success = false;

@ -704,6 +704,31 @@ TEST_F(FormatConvertTest, FloatRound) {
"1837869002408041296803276054561138153076171875"); "1837869002408041296803276054561138153076171875");
} }
// We don't actually store the results. This is just to exercise the rest of the
// machinery.
struct NullSink {
friend void AbslFormatFlush(NullSink *sink, string_view str) {}
};
template <typename... T>
bool FormatWithNullSink(absl::string_view fmt, const T &... a) {
NullSink sink;
FormatArgImpl args[] = {FormatArgImpl(a)...};
return FormatUntyped(&sink, UntypedFormatSpecImpl(fmt), absl::MakeSpan(args));
}
TEST_F(FormatConvertTest, ExtremeWidthPrecision) {
for (const char *fmt : {"f"}) {
for (double d : {1e-100, 1.0, 1e100}) {
constexpr int max = std::numeric_limits<int>::max();
EXPECT_TRUE(FormatWithNullSink(std::string("%.*") + fmt, max, d));
EXPECT_TRUE(FormatWithNullSink(std::string("%1.*") + fmt, max, d));
EXPECT_TRUE(FormatWithNullSink(std::string("%*") + fmt, max, d));
EXPECT_TRUE(FormatWithNullSink(std::string("%*.*") + fmt, max, max, d));
}
}
}
TEST_F(FormatConvertTest, LongDouble) { TEST_F(FormatConvertTest, LongDouble) {
#ifdef _MSC_VER #ifdef _MSC_VER
// MSVC has a different rounding policy than us so we can't test our // MSVC has a different rounding policy than us so we can't test our

@ -440,8 +440,10 @@ struct Padding {
int right_spaces; int right_spaces;
}; };
Padding ExtraWidthToPadding(int total_size, const FormatState &state) { Padding ExtraWidthToPadding(size_t total_size, const FormatState &state) {
int missing_chars = std::max(state.conv.width() - total_size, 0); if (state.conv.width() < 0 || state.conv.width() <= total_size)
return {0, 0, 0};
int missing_chars = state.conv.width() - total_size;
if (state.conv.has_left_flag()) { if (state.conv.has_left_flag()) {
return {0, 0, missing_chars}; return {0, 0, missing_chars};
} else if (state.conv.has_zero_flag()) { } else if (state.conv.has_zero_flag()) {
@ -462,8 +464,8 @@ void FinalPrint(absl::string_view data, int trailing_zeros,
} }
auto padding = auto padding =
ExtraWidthToPadding((state.sign_char != '\0' ? 1 : 0) + ExtraWidthToPadding((state.sign_char != '\0' ? 1 : 0) + data.size() +
static_cast<int>(data.size()) + trailing_zeros, static_cast<size_t>(trailing_zeros),
state); state);
state.sink->Append(padding.left_spaces, ' '); state.sink->Append(padding.left_spaces, ' ');
@ -536,8 +538,9 @@ void FormatFFast(Int v, int exp, const FormatState &state) {
// worry about anything after the `.`. // worry about anything after the `.`.
void FormatFPositiveExpSlow(uint128 v, int exp, const FormatState &state) { void FormatFPositiveExpSlow(uint128 v, int exp, const FormatState &state) {
BinaryToDecimal::RunConversion(v, exp, [&](BinaryToDecimal btd) { BinaryToDecimal::RunConversion(v, exp, [&](BinaryToDecimal btd) {
const int total_digits = const size_t total_digits =
btd.TotalDigits() + (state.ShouldPrintDot() ? state.precision + 1 : 0); btd.TotalDigits() +
(state.ShouldPrintDot() ? static_cast<size_t>(state.precision) + 1 : 0);
const auto padding = ExtraWidthToPadding( const auto padding = ExtraWidthToPadding(
total_digits + (state.sign_char != '\0' ? 1 : 0), state); total_digits + (state.sign_char != '\0' ? 1 : 0), state);
@ -562,8 +565,9 @@ void FormatFPositiveExpSlow(uint128 v, int exp, const FormatState &state) {
// This one is guaranteed to be < 1.0, so we don't have to worry about integral // This one is guaranteed to be < 1.0, so we don't have to worry about integral
// digits. // digits.
void FormatFNegativeExpSlow(uint128 v, int exp, const FormatState &state) { void FormatFNegativeExpSlow(uint128 v, int exp, const FormatState &state) {
const int total_digits = const size_t total_digits =
/* 0 */ 1 + (state.ShouldPrintDot() ? state.precision + 1 : 0); /* 0 */ 1 +
(state.ShouldPrintDot() ? static_cast<size_t>(state.precision) + 1 : 0);
auto padding = auto padding =
ExtraWidthToPadding(total_digits + (state.sign_char ? 1 : 0), state); ExtraWidthToPadding(total_digits + (state.sign_char ? 1 : 0), state);
padding.zeros += 1; padding.zeros += 1;

Loading…
Cancel
Save