about summary refs log tree commit diff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--absl/debugging/internal/stacktrace_arm-inl.inc17
-rw-r--r--absl/debugging/internal/stacktrace_generic-inl.inc15
-rw-r--r--absl/flags/internal/commandlineflag.cc13
-rw-r--r--absl/flags/internal/commandlineflag.h22
-rw-r--r--absl/flags/internal/commandlineflag_test.cc70
-rw-r--r--absl/flags/internal/type_erased.cc3
-rw-r--r--absl/flags/parse.cc3
-rw-r--r--absl/strings/internal/str_format/extension.h8
-rw-r--r--absl/strings/internal/str_format/parser.cc4
-rw-r--r--absl/strings/internal/str_format/parser_test.cc2
10 files changed, 103 insertions, 54 deletions
diff --git a/absl/debugging/internal/stacktrace_arm-inl.inc b/absl/debugging/internal/stacktrace_arm-inl.inc
index fffda968dde6..2a1bf2e88694 100644
--- a/absl/debugging/internal/stacktrace_arm-inl.inc
+++ b/absl/debugging/internal/stacktrace_arm-inl.inc
@@ -1,9 +1,18 @@
-// Copyright 2011 and onwards Google Inc.
-// All rights reserved.
+// Copyright 2017 The Abseil Authors.
 //
-// Author: Doug Kwan
-// This is inspired by Craig Silverstein's PowerPC stacktrace code.
+// 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.
+//
+// This is inspired by Craig Silverstein's PowerPC stacktrace code.
 
 #ifndef ABSL_DEBUGGING_INTERNAL_STACKTRACE_ARM_INL_H_
 #define ABSL_DEBUGGING_INTERNAL_STACKTRACE_ARM_INL_H_
diff --git a/absl/debugging/internal/stacktrace_generic-inl.inc b/absl/debugging/internal/stacktrace_generic-inl.inc
index ac034c9f5b2e..b2792a1f3ada 100644
--- a/absl/debugging/internal/stacktrace_generic-inl.inc
+++ b/absl/debugging/internal/stacktrace_generic-inl.inc
@@ -1,7 +1,16 @@
-// Copyright 2000 - 2007 Google Inc.
-// All rights reserved.
+// Copyright 2017 The Abseil Authors.
 //
-// Author: Sanjay Ghemawat
+// 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.
 //
 // Portable implementation - just use glibc
 //
diff --git a/absl/flags/internal/commandlineflag.cc b/absl/flags/internal/commandlineflag.cc
index f1e50d01ec8d..c919fa1be8a7 100644
--- a/absl/flags/internal/commandlineflag.cc
+++ b/absl/flags/internal/commandlineflag.cc
@@ -23,6 +23,11 @@ FlagStateInterface::~FlagStateInterface() {}
 
 bool CommandLineFlag::IsRetired() const { return false; }
 
+bool CommandLineFlag::ParseFrom(absl::string_view value, std::string* error) {
+  return ParseFrom(value, flags_internal::SET_FLAGS_VALUE,
+                   flags_internal::kProgrammaticChange, error);
+}
+
 FlagFastTypeId PrivateHandleInterface::TypeId(const CommandLineFlag& flag) {
   return flag.TypeId();
 }
@@ -42,6 +47,14 @@ void PrivateHandleInterface::CheckDefaultValueParsingRoundtrip(
   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
 ABSL_NAMESPACE_END
 }  // namespace absl
diff --git a/absl/flags/internal/commandlineflag.h b/absl/flags/internal/commandlineflag.h
index f60204dd6256..af5e05d59984 100644
--- a/absl/flags/internal/commandlineflag.h
+++ b/absl/flags/internal/commandlineflag.h
@@ -140,6 +140,17 @@ class CommandLineFlag {
 
   // 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`
+  // to indicate the error, leaves the flag unchanged, and returns false.
+  bool ParseFrom(absl::string_view value, std::string* error);
+
+ protected:
+  ~CommandLineFlag() = default;
+
+ private:
+  friend class PrivateHandleInterface;
+
+  // 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`
   // to indicate the error, leaves the flag unchanged, and returns false. There
   // are three ways to set the flag's value:
   //  * Update the current flag value
@@ -151,12 +162,6 @@ class CommandLineFlag {
                          flags_internal::ValueSource source,
                          std::string* error) = 0;
 
- protected:
-  ~CommandLineFlag() = default;
-
- private:
-  friend class PrivateHandleInterface;
-
   // Returns id of the flag's value type.
   virtual FlagFastTypeId TypeId() const = 0;
 
@@ -168,7 +173,6 @@ class CommandLineFlag {
   // the dst based on the current flag's value.
   virtual void Read(void* dst) const = 0;
 
-  // Interfaces to operate on validators.
   // Validates supplied value usign validator or parseflag routine
   virtual bool ValidateInputValue(absl::string_view value) const = 0;
 
@@ -194,6 +198,10 @@ class PrivateHandleInterface {
 
   // 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
diff --git a/absl/flags/internal/commandlineflag_test.cc b/absl/flags/internal/commandlineflag_test.cc
index c31679f95e7a..4aeb3bf4dd3c 100644
--- a/absl/flags/internal/commandlineflag_test.cc
+++ b/absl/flags/internal/commandlineflag_test.cc
@@ -122,49 +122,53 @@ TEST_F(CommandLineFlagTest, TestParseFromCurrentValue) {
   auto* flag_01 = flags::FindCommandLineFlag("int_flag");
   EXPECT_FALSE(flag_01->IsSpecifiedOnCommandLine());
 
-  EXPECT_TRUE(flag_01->ParseFrom("11", flags::SET_FLAGS_VALUE,
-                                 flags::kProgrammaticChange, &err));
+  EXPECT_TRUE(flags::PrivateHandleInterface::ParseFrom(
+      flag_01, "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->ParseFrom("-123", flags::SET_FLAGS_VALUE,
-                                 flags::kProgrammaticChange, &err));
+  EXPECT_TRUE(flags::PrivateHandleInterface::ParseFrom(
+      flag_01, "-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->ParseFrom("xyz", flags::SET_FLAGS_VALUE,
-                                  flags::kProgrammaticChange, &err));
+  EXPECT_TRUE(!flags::PrivateHandleInterface::ParseFrom(
+      flag_01, "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->ParseFrom("A1", flags::SET_FLAGS_VALUE,
-                                  flags::kProgrammaticChange, &err));
+  EXPECT_TRUE(!flags::PrivateHandleInterface::ParseFrom(
+      flag_01, "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->ParseFrom("0x10", flags::SET_FLAGS_VALUE,
-                                 flags::kProgrammaticChange, &err));
+  EXPECT_TRUE(flags::PrivateHandleInterface::ParseFrom(
+      flag_01, "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->ParseFrom("011", flags::SET_FLAGS_VALUE,
-                                 flags::kCommandLine, &err));
+  EXPECT_TRUE(flags::PrivateHandleInterface::ParseFrom(
+      flag_01, "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->ParseFrom("", flags::SET_FLAGS_VALUE,
-                                  flags::kProgrammaticChange, &err));
+  EXPECT_TRUE(!flags::PrivateHandleInterface::ParseFrom(
+      flag_01, "", 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->ParseFrom("xyz", flags::SET_FLAGS_VALUE,
-                                 flags::kProgrammaticChange, &err));
+  EXPECT_TRUE(flags::PrivateHandleInterface::ParseFrom(
+      flag_02, "xyz", flags::SET_FLAGS_VALUE, flags::kProgrammaticChange,
+      &err));
   EXPECT_EQ(absl::GetFlag(FLAGS_string_flag), "xyz");
 
-  EXPECT_TRUE(flag_02->ParseFrom("", flags::SET_FLAGS_VALUE,
-                                 flags::kProgrammaticChange, &err));
+  EXPECT_TRUE(flags::PrivateHandleInterface::ParseFrom(
+      flag_02, "", flags::SET_FLAGS_VALUE, flags::kProgrammaticChange, &err));
   EXPECT_EQ(absl::GetFlag(FLAGS_string_flag), "");
 }
 
@@ -175,14 +179,16 @@ TEST_F(CommandLineFlagTest, TestParseFromDefaultValue) {
 
   auto* flag_01 = flags::FindCommandLineFlag("int_flag");
 
-  EXPECT_TRUE(flag_01->ParseFrom("111", flags::SET_FLAGS_DEFAULT,
-                                 flags::kProgrammaticChange, &err));
+  EXPECT_TRUE(flags::PrivateHandleInterface::ParseFrom(
+      flag_01, "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->ParseFrom("abc", flags::SET_FLAGS_DEFAULT,
-                                 flags::kProgrammaticChange, &err));
+  EXPECT_TRUE(flags::PrivateHandleInterface::ParseFrom(
+      flag_02, "abc", flags::SET_FLAGS_DEFAULT, flags::kProgrammaticChange,
+      &err));
   EXPECT_EQ(flag_02->DefaultValue(), "abc");
 }
 
@@ -193,22 +199,26 @@ TEST_F(CommandLineFlagTest, TestParseFromIfDefault) {
 
   auto* flag_01 = flags::FindCommandLineFlag("int_flag");
 
-  EXPECT_TRUE(flag_01->ParseFrom("22", flags::SET_FLAG_IF_DEFAULT,
-                                 flags::kProgrammaticChange, &err))
+  EXPECT_TRUE(flags::PrivateHandleInterface::ParseFrom(
+      flag_01, "22", flags::SET_FLAG_IF_DEFAULT, flags::kProgrammaticChange,
+      &err))
       << err;
   EXPECT_EQ(absl::GetFlag(FLAGS_int_flag), 22);
 
-  EXPECT_TRUE(flag_01->ParseFrom("33", flags::SET_FLAG_IF_DEFAULT,
-                                 flags::kProgrammaticChange, &err));
+  EXPECT_TRUE(flags::PrivateHandleInterface::ParseFrom(
+      flag_01, "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->ParseFrom("201", flags::SET_FLAGS_VALUE,
-                                 flags::kProgrammaticChange, &err));
+  EXPECT_TRUE(flags::PrivateHandleInterface::ParseFrom(
+      flag_01, "201", flags::SET_FLAGS_VALUE, flags::kProgrammaticChange,
+      &err));
 
-  EXPECT_TRUE(flag_01->ParseFrom("33", flags::SET_FLAG_IF_DEFAULT,
-                                 flags::kProgrammaticChange, &err));
+  EXPECT_TRUE(flags::PrivateHandleInterface::ParseFrom(
+      flag_01, "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/type_erased.cc b/absl/flags/internal/type_erased.cc
index 5038625be761..adeb7a1541ab 100644
--- a/absl/flags/internal/type_erased.cc
+++ b/absl/flags/internal/type_erased.cc
@@ -56,7 +56,8 @@ bool SetCommandLineOptionWithMode(absl::string_view name,
   if (!flag || flag->IsRetired()) return false;
 
   std::string error;
-  if (!flag->ParseFrom(value, set_mode, kProgrammaticChange, &error)) {
+  if (!flags_internal::PrivateHandleInterface::ParseFrom(
+          flag, 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 b76edc62d9b0..cc134909877f 100644
--- a/absl/flags/parse.cc
+++ b/absl/flags/parse.cc
@@ -697,7 +697,8 @@ std::vector<char*> ParseCommandLineImpl(int argc, char* argv[],
     if (flag->IsRetired()) continue;
 
     std::string error;
-    if (!flag->ParseFrom(value, SET_FLAGS_VALUE, kCommandLine, &error)) {
+    if (!flags_internal::PrivateHandleInterface::ParseFrom(
+            flag, value, SET_FLAGS_VALUE, kCommandLine, &error)) {
       flags_internal::ReportUsageError(error, true);
       success = false;
     }
diff --git a/absl/strings/internal/str_format/extension.h b/absl/strings/internal/str_format/extension.h
index 33903df0be39..ce78a02aefbb 100644
--- a/absl/strings/internal/str_format/extension.h
+++ b/absl/strings/internal/str_format/extension.h
@@ -143,7 +143,7 @@ struct Flags {
 // clang-format off
 #define ABSL_INTERNAL_CONVERSION_CHARS_EXPAND_(X_VAL, X_SEP) \
   /* text */ \
-  X_VAL(c) X_SEP X_VAL(C) X_SEP X_VAL(s) X_SEP X_VAL(S) X_SEP \
+  X_VAL(c) X_SEP X_VAL(s) X_SEP \
   /* ints */ \
   X_VAL(d) X_SEP X_VAL(i) X_SEP X_VAL(o) X_SEP \
   X_VAL(u) X_SEP X_VAL(x) X_SEP X_VAL(X) X_SEP \
@@ -170,7 +170,7 @@ struct FormatConversionCharInternal {
  private:
   // clang-format off
   enum class Enum : uint8_t {
-    c, C, s, S,              // text
+    c, s,                    // text
     d, i, o, u, x, X,        // int
     f, F, e, E, g, G, a, A,  // float
     n, p,                    // misc
@@ -444,7 +444,7 @@ class FormatConversionSpec {
 
 // clang-format off
 enum class FormatConversionChar : uint8_t {
-  c, C, s, S,              // text
+  c, s,                    // text
   d, i, o, u, x, X,        // int
   f, F, e, E, g, G, a, A,  // float
   n, p                     // misc
@@ -454,9 +454,7 @@ enum class FormatConversionChar : uint8_t {
 enum class FormatConversionCharSet : uint64_t {
   // text
   c = str_format_internal::FormatConversionCharToConvInt('c'),
-  C = str_format_internal::FormatConversionCharToConvInt('C'),
   s = str_format_internal::FormatConversionCharToConvInt('s'),
-  S = str_format_internal::FormatConversionCharToConvInt('S'),
   // integer
   d = str_format_internal::FormatConversionCharToConvInt('d'),
   i = str_format_internal::FormatConversionCharToConvInt('i'),
diff --git a/absl/strings/internal/str_format/parser.cc b/absl/strings/internal/str_format/parser.cc
index 61132739b875..cc55dfa9c74e 100644
--- a/absl/strings/internal/str_format/parser.cc
+++ b/absl/strings/internal/str_format/parser.cc
@@ -29,9 +29,9 @@ ABSL_CONST_INIT const ConvTag kTags[256] = {
     {},    {},    {},    {},    {},    {},    {},    {},     // 28-2f
     {},    {},    {},    {},    {},    {},    {},    {},     // 30-37
     {},    {},    {},    {},    {},    {},    {},    {},     // 38-3f
-    {},    CC::A, {},    CC::C, {},    CC::E, CC::F, CC::G,  // @ABCDEFG
+    {},    CC::A, {},    {},    {},    CC::E, CC::F, CC::G,  // @ABCDEFG
     {},    {},    {},    {},    LM::L, {},    {},    {},     // HIJKLMNO
-    {},    {},    {},    CC::S, {},    {},    {},    {},     // PQRSTUVW
+    {},    {},    {},    {},    {},    {},    {},    {},     // PQRSTUVW
     CC::X, {},    {},    {},    {},    {},    {},    {},     // XYZ[\]^_
     {},    CC::a, {},    CC::c, CC::d, CC::e, CC::f, CC::g,  // `abcdefg
     LM::h, CC::i, LM::j, {},    LM::l, {},    CC::n, CC::o,  // hijklmno
diff --git a/absl/strings/internal/str_format/parser_test.cc b/absl/strings/internal/str_format/parser_test.cc
index dae2d20f593e..5aced987200d 100644
--- a/absl/strings/internal/str_format/parser_test.cc
+++ b/absl/strings/internal/str_format/parser_test.cc
@@ -47,7 +47,7 @@ TEST(ConversionCharTest, Names) {
   // clang-format off
   const Expectation kExpect[] = {
 #define X(c) {FormatConversionCharInternal::c, #c[0]}
-    X(c), X(C), X(s), X(S),                          // text
+    X(c), X(s),                                      // text
     X(d), X(i), X(o), X(u), X(x), X(X),              // int
     X(f), X(F), X(e), X(E), X(g), X(G), X(a), X(A),  // float
     X(n), X(p),                                      // misc
generated by cgit-pink 1.4.1 (git 2.44.2) at 2024-07-30T16ยท16+0000