Export of internal Abseil changes

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

Rename ComamndLineFlag's interface SetFromString as ParseFrom.

This is the name approved by C++ API review.

PiperOrigin-RevId: 301543521

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

Internal change

PiperOrigin-RevId: 301524919

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

Introduce absl::base_internal::StrError, a portability wrapper around the various thread-safe alternatives to C89's strerror.

PiperOrigin-RevId: 301513962

--
92ccac3b6eb18cb41cddedbfdab53b9ad481505d by Andy Getzendanner <durandal@google.com>:

Introduce absl::base_internal::StrError, a portability wrapper around the various thread-safe alternatives to C89's strerror.

PiperOrigin-RevId: 301493389

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

Internal change

PiperOrigin-RevId: 301363394

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

Add validation for size of void* to match the size of free function pointer.

PiperOrigin-RevId: 301341331
GitOrigin-RevId: a85860e450815776c8753f34348f41ab0e918d36
Change-Id: I27c9d1365d3c9b4328d1587ab3ac38e2d09a6ec2

7 files changed, 60 insertions, 51 deletions

diff --git a/absl/flags/internal/commandlineflag.h b/absl/flags/internal/commandlineflag.h
index 9a740d5744f8..338a1228dacb 100644
--- a/absl/flags/internal/commandlineflag.h
+++ b/absl/flags/internal/commandlineflag.h
@@ -65,7 +65,7 @@ enum FlagSettingMode {
   SET_FLAGS_DEFAULT
 };
 
-// Options that control SetFromString: Source of a value.
+// Options that control ParseFrom: Source of a value.
 enum ValueSource {
   // Flag is being set by value specified on a command line.
   kCommandLine,
@@ -171,10 +171,10 @@ class CommandLineFlag {
   //  * Update the flag's default value
   //  * Update the current flag value if it was never set before
   // The mode is selected based on `set_mode` parameter.
-  virtual bool SetFromString(absl::string_view value,
-                             flags_internal::FlagSettingMode set_mode,
-                             flags_internal::ValueSource source,
-                             std::string* error) = 0;
+  virtual bool ParseFrom(absl::string_view value,
+                         flags_internal::FlagSettingMode set_mode,
+                         flags_internal::ValueSource source,
+                         std::string* error) = 0;
 
   // Checks that flags default value can be converted to string and back to the
   // flag's value type.
diff --git a/absl/flags/internal/commandlineflag_test.cc b/absl/flags/internal/commandlineflag_test.cc
index 0e8bc3133b53..c1142b7c5720 100644
--- a/absl/flags/internal/commandlineflag_test.cc
+++ b/absl/flags/internal/commandlineflag_test.cc
@@ -119,99 +119,99 @@ TEST_F(CommandLineFlagTest, TestValueAccessMethods) {
 
 // --------------------------------------------------------------------
 
-TEST_F(CommandLineFlagTest, TestSetFromStringCurrentValue) {
+TEST_F(CommandLineFlagTest, TestParseFromCurrentValue) {
   std::string err;
 
   auto* flag_01 = flags::FindCommandLineFlag("int_flag");
   EXPECT_FALSE(flag_01->IsSpecifiedOnCommandLine());
 
-  EXPECT_TRUE(flag_01->SetFromString("11", flags::SET_FLAGS_VALUE,
-                                     flags::kProgrammaticChange, &err));
+  EXPECT_TRUE(flag_01->ParseFrom("11", flags::SET_FLAGS_VALUE,
+                                 flags::kProgrammaticChange, &err));
   EXPECT_EQ(absl::GetFlag(FLAGS_int_flag), 11);
   EXPECT_FALSE(flag_01->IsSpecifiedOnCommandLine());
 
-  EXPECT_TRUE(flag_01->SetFromString("-123", flags::SET_FLAGS_VALUE,
-                                     flags::kProgrammaticChange, &err));
+  EXPECT_TRUE(flag_01->ParseFrom("-123", flags::SET_FLAGS_VALUE,
+                                 flags::kProgrammaticChange, &err));
   EXPECT_EQ(absl::GetFlag(FLAGS_int_flag), -123);
   EXPECT_FALSE(flag_01->IsSpecifiedOnCommandLine());
 
-  EXPECT_TRUE(!flag_01->SetFromString("xyz", flags::SET_FLAGS_VALUE,
-                                      flags::kProgrammaticChange, &err));
+  EXPECT_TRUE(!flag_01->ParseFrom("xyz", flags::SET_FLAGS_VALUE,
+                                  flags::kProgrammaticChange, &err));
   EXPECT_EQ(absl::GetFlag(FLAGS_int_flag), -123);
   EXPECT_EQ(err, "Illegal value 'xyz' specified for flag 'int_flag'");
   EXPECT_FALSE(flag_01->IsSpecifiedOnCommandLine());
 
-  EXPECT_TRUE(!flag_01->SetFromString("A1", flags::SET_FLAGS_VALUE,
-                                      flags::kProgrammaticChange, &err));
+  EXPECT_TRUE(!flag_01->ParseFrom("A1", flags::SET_FLAGS_VALUE,
+                                  flags::kProgrammaticChange, &err));
   EXPECT_EQ(absl::GetFlag(FLAGS_int_flag), -123);
   EXPECT_EQ(err, "Illegal value 'A1' specified for flag 'int_flag'");
   EXPECT_FALSE(flag_01->IsSpecifiedOnCommandLine());
 
-  EXPECT_TRUE(flag_01->SetFromString("0x10", flags::SET_FLAGS_VALUE,
-                                     flags::kProgrammaticChange, &err));
+  EXPECT_TRUE(flag_01->ParseFrom("0x10", flags::SET_FLAGS_VALUE,
+                                 flags::kProgrammaticChange, &err));
   EXPECT_EQ(absl::GetFlag(FLAGS_int_flag), 16);
   EXPECT_FALSE(flag_01->IsSpecifiedOnCommandLine());
 
-  EXPECT_TRUE(flag_01->SetFromString("011", flags::SET_FLAGS_VALUE,
-                                     flags::kCommandLine, &err));
+  EXPECT_TRUE(flag_01->ParseFrom("011", flags::SET_FLAGS_VALUE,
+                                 flags::kCommandLine, &err));
   EXPECT_EQ(absl::GetFlag(FLAGS_int_flag), 11);
   EXPECT_TRUE(flag_01->IsSpecifiedOnCommandLine());
 
-  EXPECT_TRUE(!flag_01->SetFromString("", flags::SET_FLAGS_VALUE,
-                                      flags::kProgrammaticChange, &err));
+  EXPECT_TRUE(!flag_01->ParseFrom("", flags::SET_FLAGS_VALUE,
+                                  flags::kProgrammaticChange, &err));
   EXPECT_EQ(err, "Illegal value '' specified for flag 'int_flag'");
 
   auto* flag_02 = flags::FindCommandLineFlag("string_flag");
-  EXPECT_TRUE(flag_02->SetFromString("xyz", flags::SET_FLAGS_VALUE,
-                                     flags::kProgrammaticChange, &err));
+  EXPECT_TRUE(flag_02->ParseFrom("xyz", flags::SET_FLAGS_VALUE,
+                                 flags::kProgrammaticChange, &err));
   EXPECT_EQ(absl::GetFlag(FLAGS_string_flag), "xyz");
 
-  EXPECT_TRUE(flag_02->SetFromString("", flags::SET_FLAGS_VALUE,
-                                     flags::kProgrammaticChange, &err));
+  EXPECT_TRUE(flag_02->ParseFrom("", flags::SET_FLAGS_VALUE,
+                                 flags::kProgrammaticChange, &err));
   EXPECT_EQ(absl::GetFlag(FLAGS_string_flag), "");
 }
 
 // --------------------------------------------------------------------
 
-TEST_F(CommandLineFlagTest, TestSetFromStringDefaultValue) {
+TEST_F(CommandLineFlagTest, TestParseFromDefaultValue) {
   std::string err;
 
   auto* flag_01 = flags::FindCommandLineFlag("int_flag");
 
-  EXPECT_TRUE(flag_01->SetFromString("111", flags::SET_FLAGS_DEFAULT,
-                                     flags::kProgrammaticChange, &err));
+  EXPECT_TRUE(flag_01->ParseFrom("111", flags::SET_FLAGS_DEFAULT,
+                                 flags::kProgrammaticChange, &err));
   EXPECT_EQ(flag_01->DefaultValue(), "111");
 
   auto* flag_02 = flags::FindCommandLineFlag("string_flag");
 
-  EXPECT_TRUE(flag_02->SetFromString("abc", flags::SET_FLAGS_DEFAULT,
-                                     flags::kProgrammaticChange, &err));
+  EXPECT_TRUE(flag_02->ParseFrom("abc", flags::SET_FLAGS_DEFAULT,
+                                 flags::kProgrammaticChange, &err));
   EXPECT_EQ(flag_02->DefaultValue(), "abc");
 }
 
 // --------------------------------------------------------------------
 
-TEST_F(CommandLineFlagTest, TestSetFromStringIfDefault) {
+TEST_F(CommandLineFlagTest, TestParseFromIfDefault) {
   std::string err;
 
   auto* flag_01 = flags::FindCommandLineFlag("int_flag");
 
-  EXPECT_TRUE(flag_01->SetFromString("22", flags::SET_FLAG_IF_DEFAULT,
-                                     flags::kProgrammaticChange, &err))
+  EXPECT_TRUE(flag_01->ParseFrom("22", flags::SET_FLAG_IF_DEFAULT,
+                                 flags::kProgrammaticChange, &err))
       << err;
   EXPECT_EQ(absl::GetFlag(FLAGS_int_flag), 22);
 
-  EXPECT_TRUE(flag_01->SetFromString("33", flags::SET_FLAG_IF_DEFAULT,
-                                     flags::kProgrammaticChange, &err));
+  EXPECT_TRUE(flag_01->ParseFrom("33", flags::SET_FLAG_IF_DEFAULT,
+                                 flags::kProgrammaticChange, &err));
   EXPECT_EQ(absl::GetFlag(FLAGS_int_flag), 22);
   // EXPECT_EQ(err, "ERROR: int_flag is already set to 22");
 
   // Reset back to default value
-  EXPECT_TRUE(flag_01->SetFromString("201", flags::SET_FLAGS_VALUE,
-                                     flags::kProgrammaticChange, &err));
+  EXPECT_TRUE(flag_01->ParseFrom("201", flags::SET_FLAGS_VALUE,
+                                 flags::kProgrammaticChange, &err));
 
-  EXPECT_TRUE(flag_01->SetFromString("33", flags::SET_FLAG_IF_DEFAULT,
-                                     flags::kProgrammaticChange, &err));
+  EXPECT_TRUE(flag_01->ParseFrom("33", flags::SET_FLAG_IF_DEFAULT,
+                                 flags::kProgrammaticChange, &err));
   EXPECT_EQ(absl::GetFlag(FLAGS_int_flag), 201);
   // EXPECT_EQ(err, "ERROR: int_flag is already set to 201");
 }
diff --git a/absl/flags/internal/flag.cc b/absl/flags/internal/flag.cc
index a12fe7c5e3d4..a45e883e071c 100644
--- a/absl/flags/internal/flag.cc
+++ b/absl/flags/internal/flag.cc
@@ -338,8 +338,8 @@ void FlagImpl::Write(const void* src) {
 //  * Update the flag's default value
 //  * Update the current flag value if it was never set before
 // The mode is selected based on 'set_mode' parameter.
-bool FlagImpl::SetFromString(absl::string_view value, FlagSettingMode set_mode,
-                             ValueSource source, std::string* err) {
+bool FlagImpl::ParseFrom(absl::string_view value, FlagSettingMode set_mode,
+                         ValueSource source, std::string* err) {
   absl::MutexLock l(DataGuard());
 
   switch (set_mode) {
diff --git a/absl/flags/internal/flag.h b/absl/flags/internal/flag.h
index 0ef0ee745641..2c4aba680a6e 100644
--- a/absl/flags/internal/flag.h
+++ b/absl/flags/internal/flag.h
@@ -76,8 +76,17 @@ void* FlagOps(FlagOp op, const void* v1, void* v2, void* v3) {
       return nullptr;
     case FlagOp::kSizeof:
       return reinterpret_cast<void*>(sizeof(T));
-    case FlagOp::kStaticTypeId:
-      return reinterpret_cast<void*>(&FlagStaticTypeIdGen<T>);
+    case FlagOp::kStaticTypeId: {
+      auto* static_id = &FlagStaticTypeIdGen<T>;
+
+      // Cast from function pointer to void* is not portable.
+      // We don't have an easy way to work around this, but it works fine
+      // on all the platforms we test and as long as size of pointers match
+      // we should be fine to do reinterpret cast.
+      static_assert(sizeof(void*) == sizeof(static_id),
+                    "Flag's static type id does not work on this platform");
+      return reinterpret_cast<void*>(static_id);
+    }
     case FlagOp::kParse: {
       // Initialize the temporary instance of type T based on current value in
       // destination (which is going to be flag's default value).
@@ -395,8 +404,8 @@ class FlagImpl {
 
   // Mutating access methods
   void Write(const void* src) ABSL_LOCKS_EXCLUDED(*DataGuard());
-  bool SetFromString(absl::string_view value, FlagSettingMode set_mode,
-                     ValueSource source, std::string* err)
+  bool ParseFrom(absl::string_view value, FlagSettingMode set_mode,
+                 ValueSource source, std::string* err)
       ABSL_LOCKS_EXCLUDED(*DataGuard());
 
   // Interfaces to operate on callbacks.
@@ -586,9 +595,9 @@ class Flag final : public flags_internal::CommandLineFlag {
     return impl_.RestoreState(&flag_state.cur_value_, flag_state.modified_,
                               flag_state.on_command_line_, flag_state.counter_);
   }
-  bool SetFromString(absl::string_view value, FlagSettingMode set_mode,
-                     ValueSource source, std::string* error) override {
-    return impl_.SetFromString(value, set_mode, source, error);
+  bool ParseFrom(absl::string_view value, FlagSettingMode set_mode,
+                 ValueSource source, std::string* error) override {
+    return impl_.ParseFrom(value, set_mode, source, error);
   }
   void CheckDefaultValueParsingRoundtrip() const override {
     impl_.CheckDefaultValueParsingRoundtrip();
diff --git a/absl/flags/internal/registry.cc b/absl/flags/internal/registry.cc
index e434a8591224..9ed912140ee7 100644
--- a/absl/flags/internal/registry.cc
+++ b/absl/flags/internal/registry.cc
@@ -306,8 +306,8 @@ class RetiredFlagObj final : public flags_internal::CommandLineFlag {
     return nullptr;
   }
 
-  bool SetFromString(absl::string_view, flags_internal::FlagSettingMode,
-                     flags_internal::ValueSource, std::string*) override {
+  bool ParseFrom(absl::string_view, flags_internal::FlagSettingMode,
+                 flags_internal::ValueSource, std::string*) override {
     return false;
   }
 
diff --git a/absl/flags/internal/type_erased.cc b/absl/flags/internal/type_erased.cc
index 490bc4ebae25..75b4cdf891a8 100644
--- a/absl/flags/internal/type_erased.cc
+++ b/absl/flags/internal/type_erased.cc
@@ -56,7 +56,7 @@ bool SetCommandLineOptionWithMode(absl::string_view name,
   if (!flag || flag->IsRetired()) return false;
 
   std::string error;
-  if (!flag->SetFromString(value, set_mode, kProgrammaticChange, &error)) {
+  if (!flag->ParseFrom(value, set_mode, kProgrammaticChange, &error)) {
     // Errors here are all of the form: the provided name was a recognized
     // flag, but the value was invalid (bad type, or validation failed).
     flags_internal::ReportUsageError(error, false);
diff --git a/absl/flags/parse.cc b/absl/flags/parse.cc
index af5fb12dc8de..b60b36f60868 100644
--- a/absl/flags/parse.cc
+++ b/absl/flags/parse.cc
@@ -696,7 +696,7 @@ std::vector<char*> ParseCommandLineImpl(int argc, char* argv[],
     if (flag->IsRetired()) continue;
 
     std::string error;
-    if (!flag->SetFromString(value, SET_FLAGS_VALUE, kCommandLine, &error)) {
+    if (!flag->ParseFrom(value, SET_FLAGS_VALUE, kCommandLine, &error)) {
       flags_internal::ReportUsageError(error, true);
       success = false;
     }