grpc 1.50.0-x86_64-linux → 1.52.0.pre2-x86_64-linux

data/third_party/abseil-cpp/absl/strings/escaping.cc

@@ -1,949 +0,0 @@
-// Copyright 2017 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/strings/escaping.h"
-
-#include <algorithm>
-#include <cassert>
-#include <cstdint>
-#include <cstring>
-#include <iterator>
-#include <limits>
-#include <string>
-
-#include "absl/base/internal/endian.h"
-#include "absl/base/internal/raw_logging.h"
-#include "absl/base/internal/unaligned_access.h"
-#include "absl/strings/internal/char_map.h"
-#include "absl/strings/internal/escaping.h"
-#include "absl/strings/internal/resize_uninitialized.h"
-#include "absl/strings/internal/utf8.h"
-#include "absl/strings/str_cat.h"
-#include "absl/strings/str_join.h"
-#include "absl/strings/string_view.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace {
-
-// These are used for the leave_nulls_escaped argument to CUnescapeInternal().
-constexpr bool kUnescapeNulls = false;
-
-inline bool is_octal_digit(char c) { return ('0' <= c) && (c <= '7'); }
-
-inline int hex_digit_to_int(char c) {
-  static_assert('0' == 0x30 && 'A' == 0x41 && 'a' == 0x61,
-                "Character set must be ASCII.");
-  assert(absl::ascii_isxdigit(c));
-  int x = static_cast<unsigned char>(c);
-  if (x > '9') {
-    x += 9;
-  }
-  return x & 0xf;
-}
-
-inline bool IsSurrogate(char32_t c, absl::string_view src, std::string* error) {
-  if (c >= 0xD800 && c <= 0xDFFF) {
-    if (error) {
-      *error = absl::StrCat("invalid surrogate character (0xD800-DFFF): \\",
-                            src);
-    }
-    return true;
-  }
-  return false;
-}
-
-// ----------------------------------------------------------------------
-// CUnescapeInternal()
-//    Implements both CUnescape() and CUnescapeForNullTerminatedString().
-//
-//    Unescapes C escape sequences and is the reverse of CEscape().
-//
-//    If 'source' is valid, stores the unescaped string and its size in
-//    'dest' and 'dest_len' respectively, and returns true. Otherwise
-//    returns false and optionally stores the error description in
-//    'error'. Set 'error' to nullptr to disable error reporting.
-//
-//    'dest' should point to a buffer that is at least as big as 'source'.
-//    'source' and 'dest' may be the same.
-//
-//     NOTE: any changes to this function must also be reflected in the older
-//     UnescapeCEscapeSequences().
-// ----------------------------------------------------------------------
-bool CUnescapeInternal(absl::string_view source, bool leave_nulls_escaped,
-                       char* dest, ptrdiff_t* dest_len, std::string* error) {
-  char* d = dest;
-  const char* p = source.data();
-  const char* end = p + source.size();
-  const char* last_byte = end - 1;
-
-  // Small optimization for case where source = dest and there's no escaping
-  while (p == d && p < end && *p != '\\') p++, d++;
-
-  while (p < end) {
-    if (*p != '\\') {
-      *d++ = *p++;
-    } else {
-      if (++p > last_byte) {  // skip past the '\\'
-        if (error) *error = "String cannot end with \\";
-        return false;
-      }
-      switch (*p) {
-        case 'a':  *d++ = '\a';  break;
-        case 'b':  *d++ = '\b';  break;
-        case 'f':  *d++ = '\f';  break;
-        case 'n':  *d++ = '\n';  break;
-        case 'r':  *d++ = '\r';  break;
-        case 't':  *d++ = '\t';  break;
-        case 'v':  *d++ = '\v';  break;
-        case '\\': *d++ = '\\';  break;
-        case '?':  *d++ = '\?';  break;    // \?  Who knew?
-        case '\'': *d++ = '\'';  break;
-        case '"':  *d++ = '\"';  break;
-        case '0':
-        case '1':
-        case '2':
-        case '3':
-        case '4':
-        case '5':
-        case '6':
-        case '7': {
-          // octal digit: 1 to 3 digits
-          const char* octal_start = p;
-          unsigned int ch = *p - '0';
-          if (p < last_byte && is_octal_digit(p[1])) ch = ch * 8 + *++p - '0';
-          if (p < last_byte && is_octal_digit(p[1]))
-            ch = ch * 8 + *++p - '0';      // now points at last digit
-          if (ch > 0xff) {
-            if (error) {
-              *error = "Value of \\" +
-                       std::string(octal_start, p + 1 - octal_start) +
-                       " exceeds 0xff";
-            }
-            return false;
-          }
-          if ((ch == 0) && leave_nulls_escaped) {
-            // Copy the escape sequence for the null character
-            const ptrdiff_t octal_size = p + 1 - octal_start;
-            *d++ = '\\';
-            memmove(d, octal_start, octal_size);
-            d += octal_size;
-            break;
-          }
-          *d++ = ch;
-          break;
-        }
-        case 'x':
-        case 'X': {
-          if (p >= last_byte) {
-            if (error) *error = "String cannot end with \\x";
-            return false;
-          } else if (!absl::ascii_isxdigit(p[1])) {
-            if (error) *error = "\\x cannot be followed by a non-hex digit";
-            return false;
-          }
-          unsigned int ch = 0;
-          const char* hex_start = p;
-          while (p < last_byte && absl::ascii_isxdigit(p[1]))
-            // Arbitrarily many hex digits
-            ch = (ch << 4) + hex_digit_to_int(*++p);
-          if (ch > 0xFF) {
-            if (error) {
-              *error = "Value of \\" +
-                       std::string(hex_start, p + 1 - hex_start) +
-                       " exceeds 0xff";
-            }
-            return false;
-          }
-          if ((ch == 0) && leave_nulls_escaped) {
-            // Copy the escape sequence for the null character
-            const ptrdiff_t hex_size = p + 1 - hex_start;
-            *d++ = '\\';
-            memmove(d, hex_start, hex_size);
-            d += hex_size;
-            break;
-          }
-          *d++ = ch;
-          break;
-        }
-        case 'u': {
-          // \uhhhh => convert 4 hex digits to UTF-8
-          char32_t rune = 0;
-          const char* hex_start = p;
-          if (p + 4 >= end) {
-            if (error) {
-              *error = "\\u must be followed by 4 hex digits: \\" +
-                       std::string(hex_start, p + 1 - hex_start);
-            }
-            return false;
-          }
-          for (int i = 0; i < 4; ++i) {
-            // Look one char ahead.
-            if (absl::ascii_isxdigit(p[1])) {
-              rune = (rune << 4) + hex_digit_to_int(*++p);  // Advance p.
-            } else {
-              if (error) {
-                *error = "\\u must be followed by 4 hex digits: \\" +
-                         std::string(hex_start, p + 1 - hex_start);
-              }
-              return false;
-            }
-          }
-          if ((rune == 0) && leave_nulls_escaped) {
-            // Copy the escape sequence for the null character
-            *d++ = '\\';
-            memmove(d, hex_start, 5);  // u0000
-            d += 5;
-            break;
-          }
-          if (IsSurrogate(rune, absl::string_view(hex_start, 5), error)) {
-            return false;
-          }
-          d += strings_internal::EncodeUTF8Char(d, rune);
-          break;
-        }
-        case 'U': {
-          // \Uhhhhhhhh => convert 8 hex digits to UTF-8
-          char32_t rune = 0;
-          const char* hex_start = p;
-          if (p + 8 >= end) {
-            if (error) {
-              *error = "\\U must be followed by 8 hex digits: \\" +
-                       std::string(hex_start, p + 1 - hex_start);
-            }
-            return false;
-          }
-          for (int i = 0; i < 8; ++i) {
-            // Look one char ahead.
-            if (absl::ascii_isxdigit(p[1])) {
-              // Don't change rune until we're sure this
-              // is within the Unicode limit, but do advance p.
-              uint32_t newrune = (rune << 4) + hex_digit_to_int(*++p);
-              if (newrune > 0x10FFFF) {
-                if (error) {
-                  *error = "Value of \\" +
-                           std::string(hex_start, p + 1 - hex_start) +
-                           " exceeds Unicode limit (0x10FFFF)";
-                }
-                return false;
-              } else {
-                rune = newrune;
-              }
-            } else {
-              if (error) {
-                *error = "\\U must be followed by 8 hex digits: \\" +
-                         std::string(hex_start, p + 1 - hex_start);
-              }
-              return false;
-            }
-          }
-          if ((rune == 0) && leave_nulls_escaped) {
-            // Copy the escape sequence for the null character
-            *d++ = '\\';
-            memmove(d, hex_start, 9);  // U00000000
-            d += 9;
-            break;
-          }
-          if (IsSurrogate(rune, absl::string_view(hex_start, 9), error)) {
-            return false;
-          }
-          d += strings_internal::EncodeUTF8Char(d, rune);
-          break;
-        }
-        default: {
-          if (error) *error = std::string("Unknown escape sequence: \\") + *p;
-          return false;
-        }
-      }
-      p++;                                 // read past letter we escaped
-    }
-  }
-  *dest_len = d - dest;
-  return true;
-}
-
-// ----------------------------------------------------------------------
-// CUnescapeInternal()
-//
-//    Same as above but uses a std::string for output. 'source' and 'dest'
-//    may be the same.
-// ----------------------------------------------------------------------
-bool CUnescapeInternal(absl::string_view source, bool leave_nulls_escaped,
-                       std::string* dest, std::string* error) {
-  strings_internal::STLStringResizeUninitialized(dest, source.size());
-
-  ptrdiff_t dest_size;
-  if (!CUnescapeInternal(source,
-                         leave_nulls_escaped,
-                         &(*dest)[0],
-                         &dest_size,
-                         error)) {
-    return false;
-  }
-  dest->erase(dest_size);
-  return true;
-}
-
-// ----------------------------------------------------------------------
-// CEscape()
-// CHexEscape()
-// Utf8SafeCEscape()
-// Utf8SafeCHexEscape()
-//    Escapes 'src' using C-style escape sequences.  This is useful for
-//    preparing query flags.  The 'Hex' version uses hexadecimal rather than
-//    octal sequences.  The 'Utf8Safe' version does not touch UTF-8 bytes.
-//
-//    Escaped chars: \n, \r, \t, ", ', \, and !absl::ascii_isprint().
-// ----------------------------------------------------------------------
-std::string CEscapeInternal(absl::string_view src, bool use_hex,
-                            bool utf8_safe) {
-  std::string dest;
-  bool last_hex_escape = false;  // true if last output char was \xNN.
-
-  for (unsigned char c : src) {
-    bool is_hex_escape = false;
-    switch (c) {
-      case '\n': dest.append("\\" "n"); break;
-      case '\r': dest.append("\\" "r"); break;
-      case '\t': dest.append("\\" "t"); break;
-      case '\"': dest.append("\\" "\""); break;
-      case '\'': dest.append("\\" "'"); break;
-      case '\\': dest.append("\\" "\\"); break;
-      default:
-        // Note that if we emit \xNN and the src character after that is a hex
-        // digit then that digit must be escaped too to prevent it being
-        // interpreted as part of the character code by C.
-        if ((!utf8_safe || c < 0x80) &&
-            (!absl::ascii_isprint(c) ||
-             (last_hex_escape && absl::ascii_isxdigit(c)))) {
-          if (use_hex) {
-            dest.append("\\" "x");
-            dest.push_back(numbers_internal::kHexChar[c / 16]);
-            dest.push_back(numbers_internal::kHexChar[c % 16]);
-            is_hex_escape = true;
-          } else {
-            dest.append("\\");
-            dest.push_back(numbers_internal::kHexChar[c / 64]);
-            dest.push_back(numbers_internal::kHexChar[(c % 64) / 8]);
-            dest.push_back(numbers_internal::kHexChar[c % 8]);
-          }
-        } else {
-          dest.push_back(c);
-          break;
-        }
-    }
-    last_hex_escape = is_hex_escape;
-  }
-
-  return dest;
-}
-
-/* clang-format off */
-constexpr char c_escaped_len[256] = {
-    4, 4, 4, 4, 4, 4, 4, 4, 4, 2, 2, 4, 4, 2, 4, 4,  // \t, \n, \r
-    4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
-    1, 1, 2, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1,  // ", '
-    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  // '0'..'9'
-    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  // 'A'..'O'
-    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1,  // 'P'..'Z', '\'
-    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  // 'a'..'o'
-    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 4,  // 'p'..'z', DEL
-    4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
-    4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
-    4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
-    4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
-    4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
-    4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
-    4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
-    4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
-};
-/* clang-format on */
-
-// Calculates the length of the C-style escaped version of 'src'.
-// Assumes that non-printable characters are escaped using octal sequences, and
-// that UTF-8 bytes are not handled specially.
-inline size_t CEscapedLength(absl::string_view src) {
-  size_t escaped_len = 0;
-  for (unsigned char c : src) escaped_len += c_escaped_len[c];
-  return escaped_len;
-}
-
-void CEscapeAndAppendInternal(absl::string_view src, std::string* dest) {
-  size_t escaped_len = CEscapedLength(src);
-  if (escaped_len == src.size()) {
-    dest->append(src.data(), src.size());
-    return;
-  }
-
-  size_t cur_dest_len = dest->size();
-  strings_internal::STLStringResizeUninitialized(dest,
-                                                 cur_dest_len + escaped_len);
-  char* append_ptr = &(*dest)[cur_dest_len];
-
-  for (unsigned char c : src) {
-    int char_len = c_escaped_len[c];
-    if (char_len == 1) {
-      *append_ptr++ = c;
-    } else if (char_len == 2) {
-      switch (c) {
-        case '\n':
-          *append_ptr++ = '\\';
-          *append_ptr++ = 'n';
-          break;
-        case '\r':
-          *append_ptr++ = '\\';
-          *append_ptr++ = 'r';
-          break;
-        case '\t':
-          *append_ptr++ = '\\';
-          *append_ptr++ = 't';
-          break;
-        case '\"':
-          *append_ptr++ = '\\';
-          *append_ptr++ = '\"';
-          break;
-        case '\'':
-          *append_ptr++ = '\\';
-          *append_ptr++ = '\'';
-          break;
-        case '\\':
-          *append_ptr++ = '\\';
-          *append_ptr++ = '\\';
-          break;
-      }
-    } else {
-      *append_ptr++ = '\\';
-      *append_ptr++ = '0' + c / 64;
-      *append_ptr++ = '0' + (c % 64) / 8;
-      *append_ptr++ = '0' + c % 8;
-    }
-  }
-}
-
-bool Base64UnescapeInternal(const char* src_param, size_t szsrc, char* dest,
-                            size_t szdest, const signed char* unbase64,
-                            size_t* len) {
-  static const char kPad64Equals = '=';
-  static const char kPad64Dot = '.';
-
-  size_t destidx = 0;
-  int decode = 0;
-  int state = 0;
-  unsigned int ch = 0;
-  unsigned int temp = 0;
-
-  // If "char" is signed by default, using *src as an array index results in
-  // accessing negative array elements. Treat the input as a pointer to
-  // unsigned char to avoid this.
-  const unsigned char* src = reinterpret_cast<const unsigned char*>(src_param);
-
-  // The GET_INPUT macro gets the next input character, skipping
-  // over any whitespace, and stopping when we reach the end of the
-  // string or when we read any non-data character.  The arguments are
-  // an arbitrary identifier (used as a label for goto) and the number
-  // of data bytes that must remain in the input to avoid aborting the
-  // loop.
-#define GET_INPUT(label, remain)                                \
-  label:                                                        \
-  --szsrc;                                                      \
-  ch = *src++;                                                  \
-  decode = unbase64[ch];                                        \
-  if (decode < 0) {                                             \
-    if (absl::ascii_isspace(ch) && szsrc >= remain) goto label; \
-    state = 4 - remain;                                         \
-    break;                                                      \
-  }
-
-  // if dest is null, we're just checking to see if it's legal input
-  // rather than producing output.  (I suspect this could just be done
-  // with a regexp...).  We duplicate the loop so this test can be
-  // outside it instead of in every iteration.
-
-  if (dest) {
-    // This loop consumes 4 input bytes and produces 3 output bytes
-    // per iteration.  We can't know at the start that there is enough
-    // data left in the string for a full iteration, so the loop may
-    // break out in the middle; if so 'state' will be set to the
-    // number of input bytes read.
-
-    while (szsrc >= 4) {
-      // We'll start by optimistically assuming that the next four
-      // bytes of the string (src[0..3]) are four good data bytes
-      // (that is, no nulls, whitespace, padding chars, or illegal
-      // chars).  We need to test src[0..2] for nulls individually
-      // before constructing temp to preserve the property that we
-      // never read past a null in the string (no matter how long
-      // szsrc claims the string is).
-
-      if (!src[0] || !src[1] || !src[2] ||
-          ((temp = ((unsigned(unbase64[src[0]]) << 18) |
-                    (unsigned(unbase64[src[1]]) << 12) |
-                    (unsigned(unbase64[src[2]]) << 6) |
-                    (unsigned(unbase64[src[3]])))) &
-           0x80000000)) {
-        // Iff any of those four characters was bad (null, illegal,
-        // whitespace, padding), then temp's high bit will be set
-        // (because unbase64[] is -1 for all bad characters).
-        //
-        // We'll back up and resort to the slower decoder, which knows
-        // how to handle those cases.
-
-        GET_INPUT(first, 4);
-        temp = decode;
-        GET_INPUT(second, 3);
-        temp = (temp << 6) | decode;
-        GET_INPUT(third, 2);
-        temp = (temp << 6) | decode;
-        GET_INPUT(fourth, 1);
-        temp = (temp << 6) | decode;
-      } else {
-        // We really did have four good data bytes, so advance four
-        // characters in the string.
-
-        szsrc -= 4;
-        src += 4;
-      }
-
-      // temp has 24 bits of input, so write that out as three bytes.
-
-      if (destidx + 3 > szdest) return false;
-      dest[destidx + 2] = temp;
-      temp >>= 8;
-      dest[destidx + 1] = temp;
-      temp >>= 8;
-      dest[destidx] = temp;
-      destidx += 3;
-    }
-  } else {
-    while (szsrc >= 4) {
-      if (!src[0] || !src[1] || !src[2] ||
-          ((temp = ((unsigned(unbase64[src[0]]) << 18) |
-                    (unsigned(unbase64[src[1]]) << 12) |
-                    (unsigned(unbase64[src[2]]) << 6) |
-                    (unsigned(unbase64[src[3]])))) &
-           0x80000000)) {
-        GET_INPUT(first_no_dest, 4);
-        GET_INPUT(second_no_dest, 3);
-        GET_INPUT(third_no_dest, 2);
-        GET_INPUT(fourth_no_dest, 1);
-      } else {
-        szsrc -= 4;
-        src += 4;
-      }
-      destidx += 3;
-    }
-  }
-
-#undef GET_INPUT
-
-  // if the loop terminated because we read a bad character, return
-  // now.
-  if (decode < 0 && ch != kPad64Equals && ch != kPad64Dot &&
-      !absl::ascii_isspace(ch))
-    return false;
-
-  if (ch == kPad64Equals || ch == kPad64Dot) {
-    // if we stopped by hitting an '=' or '.', un-read that character -- we'll
-    // look at it again when we count to check for the proper number of
-    // equals signs at the end.
-    ++szsrc;
-    --src;
-  } else {
-    // This loop consumes 1 input byte per iteration.  It's used to
-    // clean up the 0-3 input bytes remaining when the first, faster
-    // loop finishes.  'temp' contains the data from 'state' input
-    // characters read by the first loop.
-    while (szsrc > 0) {
-      --szsrc;
-      ch = *src++;
-      decode = unbase64[ch];
-      if (decode < 0) {
-        if (absl::ascii_isspace(ch)) {
-          continue;
-        } else if (ch == kPad64Equals || ch == kPad64Dot) {
-          // back up one character; we'll read it again when we check
-          // for the correct number of pad characters at the end.
-          ++szsrc;
-          --src;
-          break;
-        } else {
-          return false;
-        }
-      }
-
-      // Each input character gives us six bits of output.
-      temp = (temp << 6) | decode;
-      ++state;
-      if (state == 4) {
-        // If we've accumulated 24 bits of output, write that out as
-        // three bytes.
-        if (dest) {
-          if (destidx + 3 > szdest) return false;
-          dest[destidx + 2] = temp;
-          temp >>= 8;
-          dest[destidx + 1] = temp;
-          temp >>= 8;
-          dest[destidx] = temp;
-        }
-        destidx += 3;
-        state = 0;
-        temp = 0;
-      }
-    }
-  }
-
-  // Process the leftover data contained in 'temp' at the end of the input.
-  int expected_equals = 0;
-  switch (state) {
-    case 0:
-      // Nothing left over; output is a multiple of 3 bytes.
-      break;
-
-    case 1:
-      // Bad input; we have 6 bits left over.
-      return false;
-
-    case 2:
-      // Produce one more output byte from the 12 input bits we have left.
-      if (dest) {
-        if (destidx + 1 > szdest) return false;
-        temp >>= 4;
-        dest[destidx] = temp;
-      }
-      ++destidx;
-      expected_equals = 2;
-      break;
-
-    case 3:
-      // Produce two more output bytes from the 18 input bits we have left.
-      if (dest) {
-        if (destidx + 2 > szdest) return false;
-        temp >>= 2;
-        dest[destidx + 1] = temp;
-        temp >>= 8;
-        dest[destidx] = temp;
-      }
-      destidx += 2;
-      expected_equals = 1;
-      break;
-
-    default:
-      // state should have no other values at this point.
-      ABSL_RAW_LOG(FATAL, "This can't happen; base64 decoder state = %d",
-                   state);
-  }
-
-  // The remainder of the string should be all whitespace, mixed with
-  // exactly 0 equals signs, or exactly 'expected_equals' equals
-  // signs.  (Always accepting 0 equals signs is an Abseil extension
-  // not covered in the RFC, as is accepting dot as the pad character.)
-
-  int equals = 0;
-  while (szsrc > 0) {
-    if (*src == kPad64Equals || *src == kPad64Dot)
-      ++equals;
-    else if (!absl::ascii_isspace(*src))
-      return false;
-    --szsrc;
-    ++src;
-  }
-
-  const bool ok = (equals == 0 || equals == expected_equals);
-  if (ok) *len = destidx;
-  return ok;
-}
-
-// The arrays below were generated by the following code
-// #include <sys/time.h>
-// #include <stdlib.h>
-// #include <string.h>
-// main()
-// {
-//   static const char Base64[] =
-//     "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-//   char* pos;
-//   int idx, i, j;
-//   printf("    ");
-//   for (i = 0; i < 255; i += 8) {
-//     for (j = i; j < i + 8; j++) {
-//       pos = strchr(Base64, j);
-//       if ((pos == nullptr) || (j == 0))
-//         idx = -1;
-//       else
-//         idx = pos - Base64;
-//       if (idx == -1)
-//         printf(" %2d,     ", idx);
-//       else
-//         printf(" %2d/*%c*/,", idx, j);
-//     }
-//     printf("\n    ");
-//   }
-// }
-//
-// where the value of "Base64[]" was replaced by one of the base-64 conversion
-// tables from the functions below.
-/* clang-format off */
-constexpr signed char kUnBase64[] = {
-    -1,      -1,      -1,      -1,      -1,      -1,      -1,      -1,
-    -1,      -1,      -1,      -1,      -1,      -1,      -1,      -1,
-    -1,      -1,      -1,      -1,      -1,      -1,      -1,      -1,
-    -1,      -1,      -1,      -1,      -1,      -1,      -1,      -1,
-    -1,      -1,      -1,      -1,      -1,      -1,      -1,      -1,
-    -1,      -1,      -1,      62/*+*/, -1,      -1,      -1,      63/*/ */,
-    52/*0*/, 53/*1*/, 54/*2*/, 55/*3*/, 56/*4*/, 57/*5*/, 58/*6*/, 59/*7*/,
-    60/*8*/, 61/*9*/, -1,      -1,      -1,      -1,      -1,      -1,
-    -1,       0/*A*/,  1/*B*/,  2/*C*/,  3/*D*/,  4/*E*/,  5/*F*/,  6/*G*/,
-    07/*H*/,  8/*I*/,  9/*J*/, 10/*K*/, 11/*L*/, 12/*M*/, 13/*N*/, 14/*O*/,
-    15/*P*/, 16/*Q*/, 17/*R*/, 18/*S*/, 19/*T*/, 20/*U*/, 21/*V*/, 22/*W*/,
-    23/*X*/, 24/*Y*/, 25/*Z*/, -1,      -1,      -1,      -1,      -1,
-    -1,      26/*a*/, 27/*b*/, 28/*c*/, 29/*d*/, 30/*e*/, 31/*f*/, 32/*g*/,
-    33/*h*/, 34/*i*/, 35/*j*/, 36/*k*/, 37/*l*/, 38/*m*/, 39/*n*/, 40/*o*/,
-    41/*p*/, 42/*q*/, 43/*r*/, 44/*s*/, 45/*t*/, 46/*u*/, 47/*v*/, 48/*w*/,
-    49/*x*/, 50/*y*/, 51/*z*/, -1,      -1,      -1,      -1,      -1,
-    -1,      -1,      -1,      -1,      -1,      -1,      -1,      -1,
-    -1,      -1,      -1,      -1,      -1,      -1,      -1,      -1,
-    -1,      -1,      -1,      -1,      -1,      -1,      -1,      -1,
-    -1,      -1,      -1,      -1,      -1,      -1,      -1,      -1,
-    -1,      -1,      -1,      -1,      -1,      -1,      -1,      -1,
-    -1,      -1,      -1,      -1,      -1,      -1,      -1,      -1,
-    -1,      -1,      -1,      -1,      -1,      -1,      -1,      -1,
-    -1,      -1,      -1,      -1,      -1,      -1,      -1,      -1,
-    -1,      -1,      -1,      -1,      -1,      -1,      -1,      -1,
-    -1,      -1,      -1,      -1,      -1,      -1,      -1,      -1,
-    -1,      -1,      -1,      -1,      -1,      -1,      -1,      -1,
-    -1,      -1,      -1,      -1,      -1,      -1,      -1,      -1,
-    -1,      -1,      -1,      -1,      -1,      -1,      -1,      -1,
-    -1,      -1,      -1,      -1,      -1,      -1,      -1,      -1,
-    -1,      -1,      -1,      -1,      -1,      -1,      -1,      -1,
-    -1,      -1,      -1,      -1,      -1,      -1,      -1,      -1
-};
-
-constexpr signed char kUnWebSafeBase64[] = {
-    -1,      -1,      -1,      -1,      -1,      -1,      -1,      -1,
-    -1,      -1,      -1,      -1,      -1,      -1,      -1,      -1,
-    -1,      -1,      -1,      -1,      -1,      -1,      -1,      -1,
-    -1,      -1,      -1,      -1,      -1,      -1,      -1,      -1,
-    -1,      -1,      -1,      -1,      -1,      -1,      -1,      -1,
-    -1,      -1,      -1,      -1,      -1,      62/*-*/, -1,      -1,
-    52/*0*/, 53/*1*/, 54/*2*/, 55/*3*/, 56/*4*/, 57/*5*/, 58/*6*/, 59/*7*/,
-    60/*8*/, 61/*9*/, -1,      -1,      -1,      -1,      -1,      -1,
-    -1,       0/*A*/,  1/*B*/,  2/*C*/,  3/*D*/,  4/*E*/,  5/*F*/,  6/*G*/,
-    07/*H*/,  8/*I*/,  9/*J*/, 10/*K*/, 11/*L*/, 12/*M*/, 13/*N*/, 14/*O*/,
-    15/*P*/, 16/*Q*/, 17/*R*/, 18/*S*/, 19/*T*/, 20/*U*/, 21/*V*/, 22/*W*/,
-    23/*X*/, 24/*Y*/, 25/*Z*/, -1,      -1,      -1,      -1,      63/*_*/,
-    -1,      26/*a*/, 27/*b*/, 28/*c*/, 29/*d*/, 30/*e*/, 31/*f*/, 32/*g*/,
-    33/*h*/, 34/*i*/, 35/*j*/, 36/*k*/, 37/*l*/, 38/*m*/, 39/*n*/, 40/*o*/,
-    41/*p*/, 42/*q*/, 43/*r*/, 44/*s*/, 45/*t*/, 46/*u*/, 47/*v*/, 48/*w*/,
-    49/*x*/, 50/*y*/, 51/*z*/, -1,      -1,      -1,      -1,      -1,
-    -1,      -1,      -1,      -1,      -1,      -1,      -1,      -1,
-    -1,      -1,      -1,      -1,      -1,      -1,      -1,      -1,
-    -1,      -1,      -1,      -1,      -1,      -1,      -1,      -1,
-    -1,      -1,      -1,      -1,      -1,      -1,      -1,      -1,
-    -1,      -1,      -1,      -1,      -1,      -1,      -1,      -1,
-    -1,      -1,      -1,      -1,      -1,      -1,      -1,      -1,
-    -1,      -1,      -1,      -1,      -1,      -1,      -1,      -1,
-    -1,      -1,      -1,      -1,      -1,      -1,      -1,      -1,
-    -1,      -1,      -1,      -1,      -1,      -1,      -1,      -1,
-    -1,      -1,      -1,      -1,      -1,      -1,      -1,      -1,
-    -1,      -1,      -1,      -1,      -1,      -1,      -1,      -1,
-    -1,      -1,      -1,      -1,      -1,      -1,      -1,      -1,
-    -1,      -1,      -1,      -1,      -1,      -1,      -1,      -1,
-    -1,      -1,      -1,      -1,      -1,      -1,      -1,      -1,
-    -1,      -1,      -1,      -1,      -1,      -1,      -1,      -1,
-    -1,      -1,      -1,      -1,      -1,      -1,      -1,      -1
-};
-/* clang-format on */
-
-constexpr char kWebSafeBase64Chars[] =
-    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
-
-template <typename String>
-bool Base64UnescapeInternal(const char* src, size_t slen, String* dest,
-                            const signed char* unbase64) {
-  // Determine the size of the output string.  Base64 encodes every 3 bytes into
-  // 4 characters.  any leftover chars are added directly for good measure.
-  // This is documented in the base64 RFC: http://tools.ietf.org/html/rfc3548
-  const size_t dest_len = 3 * (slen / 4) + (slen % 4);
-
-  strings_internal::STLStringResizeUninitialized(dest, dest_len);
-
-  // We are getting the destination buffer by getting the beginning of the
-  // string and converting it into a char *.
-  size_t len;
-  const bool ok =
-      Base64UnescapeInternal(src, slen, &(*dest)[0], dest_len, unbase64, &len);
-  if (!ok) {
-    dest->clear();
-    return false;
-  }
-
-  // could be shorter if there was padding
-  assert(len <= dest_len);
-  dest->erase(len);
-
-  return true;
-}
-
-/* clang-format off */
-constexpr char kHexValueLenient[256] = {
-    0,  0,  0,  0,  0,  0,  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    0,  0,  0,  0,  0,  0,  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    0,  0,  0,  0,  0,  0,  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    0,  1,  2,  3,  4,  5,  6, 7, 8, 9, 0, 0, 0, 0, 0, 0,  // '0'..'9'
-    0, 10, 11, 12, 13, 14, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0,  // 'A'..'F'
-    0,  0,  0,  0,  0,  0,  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    0, 10, 11, 12, 13, 14, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0,  // 'a'..'f'
-    0,  0,  0,  0,  0,  0,  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    0,  0,  0,  0,  0,  0,  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    0,  0,  0,  0,  0,  0,  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    0,  0,  0,  0,  0,  0,  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    0,  0,  0,  0,  0,  0,  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    0,  0,  0,  0,  0,  0,  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    0,  0,  0,  0,  0,  0,  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    0,  0,  0,  0,  0,  0,  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    0,  0,  0,  0,  0,  0,  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-};
-
-/* clang-format on */
-
-// This is a templated function so that T can be either a char*
-// or a string.  This works because we use the [] operator to access
-// individual characters at a time.
-template <typename T>
-void HexStringToBytesInternal(const char* from, T to, ptrdiff_t num) {
-  for (int i = 0; i < num; i++) {
-    to[i] = (kHexValueLenient[from[i * 2] & 0xFF] << 4) +
-            (kHexValueLenient[from[i * 2 + 1] & 0xFF]);
-  }
-}
-
-// This is a templated function so that T can be either a char* or a
-// std::string.
-template <typename T>
-void BytesToHexStringInternal(const unsigned char* src, T dest, ptrdiff_t num) {
-  auto dest_ptr = &dest[0];
-  for (auto src_ptr = src; src_ptr != (src + num); ++src_ptr, dest_ptr += 2) {
-    const char* hex_p = &numbers_internal::kHexTable[*src_ptr * 2];
-    std::copy(hex_p, hex_p + 2, dest_ptr);
-  }
-}
-
-}  // namespace
-
-// ----------------------------------------------------------------------
-// CUnescape()
-//
-// See CUnescapeInternal() for implementation details.
-// ----------------------------------------------------------------------
-bool CUnescape(absl::string_view source, std::string* dest,
-               std::string* error) {
-  return CUnescapeInternal(source, kUnescapeNulls, dest, error);
-}
-
-std::string CEscape(absl::string_view src) {
-  std::string dest;
-  CEscapeAndAppendInternal(src, &dest);
-  return dest;
-}
-
-std::string CHexEscape(absl::string_view src) {
-  return CEscapeInternal(src, true, false);
-}
-
-std::string Utf8SafeCEscape(absl::string_view src) {
-  return CEscapeInternal(src, false, true);
-}
-
-std::string Utf8SafeCHexEscape(absl::string_view src) {
-  return CEscapeInternal(src, true, true);
-}
-
-// ----------------------------------------------------------------------
-// Base64Unescape() - base64 decoder
-// Base64Escape() - base64 encoder
-// WebSafeBase64Unescape() - Google's variation of base64 decoder
-// WebSafeBase64Escape() - Google's variation of base64 encoder
-//
-// Check out
-// http://tools.ietf.org/html/rfc2045 for formal description, but what we
-// care about is that...
-//   Take the encoded stuff in groups of 4 characters and turn each
-//   character into a code 0 to 63 thus:
-//           A-Z map to 0 to 25
-//           a-z map to 26 to 51
-//           0-9 map to 52 to 61
-//           +(- for WebSafe) maps to 62
-//           /(_ for WebSafe) maps to 63
-//   There will be four numbers, all less than 64 which can be represented
-//   by a 6 digit binary number (aaaaaa, bbbbbb, cccccc, dddddd respectively).
-//   Arrange the 6 digit binary numbers into three bytes as such:
-//   aaaaaabb bbbbcccc ccdddddd
-//   Equals signs (one or two) are used at the end of the encoded block to
-//   indicate that the text was not an integer multiple of three bytes long.
-// ----------------------------------------------------------------------
-
-bool Base64Unescape(absl::string_view src, std::string* dest) {
-  return Base64UnescapeInternal(src.data(), src.size(), dest, kUnBase64);
-}
-
-bool WebSafeBase64Unescape(absl::string_view src, std::string* dest) {
-  return Base64UnescapeInternal(src.data(), src.size(), dest, kUnWebSafeBase64);
-}
-
-void Base64Escape(absl::string_view src, std::string* dest) {
-  strings_internal::Base64EscapeInternal(
-      reinterpret_cast<const unsigned char*>(src.data()), src.size(), dest,
-      true, strings_internal::kBase64Chars);
-}
-
-void WebSafeBase64Escape(absl::string_view src, std::string* dest) {
-  strings_internal::Base64EscapeInternal(
-      reinterpret_cast<const unsigned char*>(src.data()), src.size(), dest,
-      false, kWebSafeBase64Chars);
-}
-
-std::string Base64Escape(absl::string_view src) {
-  std::string dest;
-  strings_internal::Base64EscapeInternal(
-      reinterpret_cast<const unsigned char*>(src.data()), src.size(), &dest,
-      true, strings_internal::kBase64Chars);
-  return dest;
-}
-
-std::string WebSafeBase64Escape(absl::string_view src) {
-  std::string dest;
-  strings_internal::Base64EscapeInternal(
-      reinterpret_cast<const unsigned char*>(src.data()), src.size(), &dest,
-      false, kWebSafeBase64Chars);
-  return dest;
-}
-
-std::string HexStringToBytes(absl::string_view from) {
-  std::string result;
-  const auto num = from.size() / 2;
-  strings_internal::STLStringResizeUninitialized(&result, num);
-  absl::HexStringToBytesInternal<std::string&>(from.data(), result, num);
-  return result;
-}
-
-std::string BytesToHexString(absl::string_view from) {
-  std::string result;
-  strings_internal::STLStringResizeUninitialized(&result, 2 * from.size());
-  absl::BytesToHexStringInternal<std::string&>(
-      reinterpret_cast<const unsigned char*>(from.data()), result, from.size());
-  return result;
-}
-
-ABSL_NAMESPACE_END
-}  // namespace absl