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

1 files changed, 45 insertions, 30 deletions

diff --git a/absl/strings/internal/str_format/parser.cc b/absl/strings/internal/str_format/parser.cc
index c3e16fceb15e..5e3d0d0547d1 100644
--- a/absl/strings/internal/str_format/parser.cc
+++ b/absl/strings/internal/str_format/parser.cc
@@ -84,16 +84,24 @@ bool ConsumeConversion(string_view *src, UnboundConversion *conv,
   const char *pos = src->data();
   const char *const end = pos + src->size();
   char c;
-  // Read the next char into `c` and update `pos`. Reads '\0' if at end.
-  const auto get_char = [&] { c = pos == end ? '\0' : *pos++; };
+  // Read the next char into `c` and update `pos`. Returns false if there are
+  // 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 = [&] {
     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
     // digit doesn't match the expected characters.
-    int num_digits = std::numeric_limits<int>::digits10 - 2;
-    for (get_char(); num_digits && std::isdigit(c); get_char()) {
+    int num_digits = std::numeric_limits<int>::digits10;
+    for (;;) {
+      if (ABSL_PREDICT_FALSE(pos == end || !num_digits)) break;
+      c = *pos++;
+      if (!std::isdigit(c)) break;
       --num_digits;
       digits = 10 * digits + c - '0';
     }
@@ -101,14 +109,14 @@ bool ConsumeConversion(string_view *src, UnboundConversion *conv,
   };
 
   if (is_positional) {
-    get_char();
-    if (c < '1' || c > '9') return false;
+    ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR();
+    if (ABSL_PREDICT_FALSE(c < '1' || c > '9')) return false;
     conv->arg_position = parse_digits();
     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.
   assert(conv->flags.basic);
@@ -119,32 +127,39 @@ bool ConsumeConversion(string_view *src, UnboundConversion *conv,
   if (c < 'A') {
     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) {
         case '-':
           conv->flags.left = true;
-          continue;
+          break;
         case '+':
           conv->flags.show_pos = true;
-          continue;
+          break;
         case ' ':
           conv->flags.sign_col = true;
-          continue;
+          break;
         case '#':
           conv->flags.alt = true;
-          continue;
+          break;
         case '0':
           conv->flags.zero = true;
-          continue;
+          break;
+        default:
+          goto flags_done;
       }
-      break;
+      ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR();
     }
+flags_done:
 
     if (c <= '9') {
       if (c >= '0') {
         int maybe_width = parse_digits();
         if (!is_positional && c == '$') {
-          if (*next_arg != 0) return false;
+          if (ABSL_PREDICT_FALSE(*next_arg != 0)) return false;
           // Positional conversion.
           *next_arg = -1;
           conv->flags = Flags();
@@ -153,12 +168,12 @@ bool ConsumeConversion(string_view *src, UnboundConversion *conv,
         }
         conv->width.set_value(maybe_width);
       } else if (c == '*') {
-        get_char();
+        ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR();
         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());
-          if (c != '$') return false;
-          get_char();
+          if (ABSL_PREDICT_FALSE(c != '$')) return false;
+          ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR();
         } else {
           conv->width.set_from_arg(++*next_arg);
         }
@@ -166,16 +181,16 @@ bool ConsumeConversion(string_view *src, UnboundConversion *conv,
     }
 
     if (c == '.') {
-      get_char();
+      ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR();
       if (std::isdigit(c)) {
         conv->precision.set_value(parse_digits());
       } else if (c == '*') {
-        get_char();
+        ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR();
         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());
           if (c != '$') return false;
-          get_char();
+          ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR();
         } else {
           conv->precision.set_from_arg(++*next_arg);
         }
@@ -188,23 +203,23 @@ bool ConsumeConversion(string_view *src, UnboundConversion *conv,
   std::int8_t id = kIds[static_cast<unsigned char>(c)];
 
   if (id < 0) {
-    if (id == none) return false;
+    if (ABSL_PREDICT_FALSE(id == none)) return false;
 
     // It is a length modifier.
     using str_format_internal::LengthMod;
     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) {
       conv->length_mod = LengthMod::FromId(LengthMod::hh);
-      get_char();
+      ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR();
     } else if (c == 'l' && length_mod.id() == LengthMod::l) {
       conv->length_mod = LengthMod::FromId(LengthMod::ll);
-      get_char();
+      ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR();
     } else {
       conv->length_mod = length_mod;
     }
     id = kIds[static_cast<unsigned char>(c)];
-    if (id < 0) return false;
+    if (ABSL_PREDICT_FALSE(id < 0)) return false;
   }
 
   assert(CheckFastPathSetting(*conv));