*** This commit represents a complete reformatting of the LLDB source code

*** to conform to clang-format’s LLVM style.  This kind of mass change has
*** two obvious implications:

Firstly, merging this particular commit into a downstream fork may be a huge
effort.  Alternatively, it may be worth merging all changes up to this commit,
performing the same reformatting operation locally, and then discarding the
merge for this particular commit.  The commands used to accomplish this
reformatting were as follows (with current working directory as the root of
the repository):

    find . \( -iname "*.c" -or -iname "*.cpp" -or -iname "*.h" -or -iname "*.mm" \) -exec clang-format -i {} +
    find . -iname "*.py" -exec autopep8 --in-place --aggressive --aggressive {} + ;

The version of clang-format used was 3.9.0, and autopep8 was 1.2.4.

Secondly, “blame” style tools will generally point to this commit instead of
a meaningful prior commit.  There are alternatives available that will attempt
to look through this change and find the appropriate prior commit.  YMMV.

llvm-svn: 280751

1 files changed, 310 insertions, 404 deletions

diff --git a/lldb/source/Utility/StringExtractor.cpp b/lldb/source/Utility/StringExtractor.cpp
index f62c8363700..d8ba39710d1 100644
--- a/lldb/source/Utility/StringExtractor.cpp
+++ b/lldb/source/Utility/StringExtractor.cpp
@@ -17,85 +17,62 @@
 // Other libraries and framework includes
 // Project includes
 
-static inline int
-xdigit_to_sint (char ch)
-{
-    if (ch >= 'a' && ch <= 'f')
-        return 10 + ch - 'a';
-    if (ch >= 'A' && ch <= 'F')
-        return 10 + ch - 'A';
-    if (ch >= '0' && ch <= '9')
-        return ch - '0';
-    return -1;
+static inline int xdigit_to_sint(char ch) {
+  if (ch >= 'a' && ch <= 'f')
+    return 10 + ch - 'a';
+  if (ch >= 'A' && ch <= 'F')
+    return 10 + ch - 'A';
+  if (ch >= '0' && ch <= '9')
+    return ch - '0';
+  return -1;
 }
 
 //----------------------------------------------------------------------
 // StringExtractor constructor
 //----------------------------------------------------------------------
-StringExtractor::StringExtractor() :
-    m_packet(),
-    m_index (0)
-{
-}
+StringExtractor::StringExtractor() : m_packet(), m_index(0) {}
 
-StringExtractor::StringExtractor(llvm::StringRef packet_str) : m_packet(), m_index(0)
-{
-    m_packet.assign(packet_str.begin(), packet_str.end());
+StringExtractor::StringExtractor(llvm::StringRef packet_str)
+    : m_packet(), m_index(0) {
+  m_packet.assign(packet_str.begin(), packet_str.end());
 }
 
-StringExtractor::StringExtractor(const char *packet_cstr) :
-    m_packet(),
-    m_index (0)
-{
-    if (packet_cstr)
-        m_packet.assign (packet_cstr);
+StringExtractor::StringExtractor(const char *packet_cstr)
+    : m_packet(), m_index(0) {
+  if (packet_cstr)
+    m_packet.assign(packet_cstr);
 }
 
-
 //----------------------------------------------------------------------
 // StringExtractor copy constructor
 //----------------------------------------------------------------------
-StringExtractor::StringExtractor(const StringExtractor& rhs) :
-    m_packet (rhs.m_packet),
-    m_index (rhs.m_index)
-{
-
-}
+StringExtractor::StringExtractor(const StringExtractor &rhs)
+    : m_packet(rhs.m_packet), m_index(rhs.m_index) {}
 
 //----------------------------------------------------------------------
 // StringExtractor assignment operator
 //----------------------------------------------------------------------
-const StringExtractor&
-StringExtractor::operator=(const StringExtractor& rhs)
-{
-    if (this != &rhs)
-    {
-        m_packet = rhs.m_packet;
-        m_index = rhs.m_index;
-
-    }
-    return *this;
+const StringExtractor &StringExtractor::operator=(const StringExtractor &rhs) {
+  if (this != &rhs) {
+    m_packet = rhs.m_packet;
+    m_index = rhs.m_index;
+  }
+  return *this;
 }
 
 //----------------------------------------------------------------------
 // Destructor
 //----------------------------------------------------------------------
-StringExtractor::~StringExtractor()
-{
-}
-
-
-char
-StringExtractor::GetChar (char fail_value)
-{
-    if (m_index < m_packet.size())
-    {
-        char ch = m_packet[m_index];
-        ++m_index;
-        return ch;
-    }
-    m_index = UINT64_MAX;
-    return fail_value;
+StringExtractor::~StringExtractor() {}
+
+char StringExtractor::GetChar(char fail_value) {
+  if (m_index < m_packet.size()) {
+    char ch = m_packet[m_index];
+    ++m_index;
+    return ch;
+  }
+  m_index = UINT64_MAX;
+  return fail_value;
 }
 
 //----------------------------------------------------------------------
@@ -106,273 +83,220 @@ StringExtractor::GetChar (char fail_value)
 // If there is not a pair of valid hex digits at the head of the
 // StringExtractor, it is left unchanged and -1 is returned
 //----------------------------------------------------------------------
-int
-StringExtractor::DecodeHexU8()
-{
-    SkipSpaces();
-    if (GetBytesLeft() < 2)
-    {
-        return -1;
-    }
-    const int hi_nibble = xdigit_to_sint(m_packet[m_index]);
-    const int lo_nibble = xdigit_to_sint(m_packet[m_index+1]);
-    if (hi_nibble == -1 || lo_nibble == -1)
-    {
-        return -1;
-    }
-    m_index += 2;
-    return (uint8_t)((hi_nibble << 4) + lo_nibble);
+int StringExtractor::DecodeHexU8() {
+  SkipSpaces();
+  if (GetBytesLeft() < 2) {
+    return -1;
+  }
+  const int hi_nibble = xdigit_to_sint(m_packet[m_index]);
+  const int lo_nibble = xdigit_to_sint(m_packet[m_index + 1]);
+  if (hi_nibble == -1 || lo_nibble == -1) {
+    return -1;
+  }
+  m_index += 2;
+  return (uint8_t)((hi_nibble << 4) + lo_nibble);
 }
 
 //----------------------------------------------------------------------
 // Extract an unsigned character from two hex ASCII chars in the packet
 // string, or return fail_value on failure
 //----------------------------------------------------------------------
-uint8_t
-StringExtractor::GetHexU8 (uint8_t fail_value, bool set_eof_on_fail)
-{
-    // On success, fail_value will be overwritten with the next
-    // character in the stream
-    GetHexU8Ex(fail_value, set_eof_on_fail);
-    return fail_value;
+uint8_t StringExtractor::GetHexU8(uint8_t fail_value, bool set_eof_on_fail) {
+  // On success, fail_value will be overwritten with the next
+  // character in the stream
+  GetHexU8Ex(fail_value, set_eof_on_fail);
+  return fail_value;
 }
 
-bool
-StringExtractor::GetHexU8Ex (uint8_t& ch, bool set_eof_on_fail)
-{
-    int byte = DecodeHexU8();
-    if (byte == -1)
-    {
-        if (set_eof_on_fail || m_index >= m_packet.size())
-            m_index = UINT64_MAX;
-        // ch should not be changed in case of failure
-        return false;
-    }
-    ch = (uint8_t)byte;
-    return true;
+bool StringExtractor::GetHexU8Ex(uint8_t &ch, bool set_eof_on_fail) {
+  int byte = DecodeHexU8();
+  if (byte == -1) {
+    if (set_eof_on_fail || m_index >= m_packet.size())
+      m_index = UINT64_MAX;
+    // ch should not be changed in case of failure
+    return false;
+  }
+  ch = (uint8_t)byte;
+  return true;
 }
 
-uint32_t
-StringExtractor::GetU32 (uint32_t fail_value, int base)
-{
-    if (m_index < m_packet.size())
-    {
-        char *end = nullptr;
-        const char *start = m_packet.c_str();
-        const char *cstr = start + m_index;
-        uint32_t result = static_cast<uint32_t>(::strtoul (cstr, &end, base));
-
-        if (end && end != cstr)
-        {
-            m_index = end - start;
-            return result;
-        }
-    }
-    return fail_value;
-}
+uint32_t StringExtractor::GetU32(uint32_t fail_value, int base) {
+  if (m_index < m_packet.size()) {
+    char *end = nullptr;
+    const char *start = m_packet.c_str();
+    const char *cstr = start + m_index;
+    uint32_t result = static_cast<uint32_t>(::strtoul(cstr, &end, base));
 
-int32_t
-StringExtractor::GetS32 (int32_t fail_value, int base)
-{
-    if (m_index < m_packet.size())
-    {
-        char *end = nullptr;
-        const char *start = m_packet.c_str();
-        const char *cstr = start + m_index;
-        int32_t result = static_cast<int32_t>(::strtol (cstr, &end, base));
-        
-        if (end && end != cstr)
-        {
-            m_index = end - start;
-            return result;
-        }
+    if (end && end != cstr) {
+      m_index = end - start;
+      return result;
     }
-    return fail_value;
+  }
+  return fail_value;
 }
 
+int32_t StringExtractor::GetS32(int32_t fail_value, int base) {
+  if (m_index < m_packet.size()) {
+    char *end = nullptr;
+    const char *start = m_packet.c_str();
+    const char *cstr = start + m_index;
+    int32_t result = static_cast<int32_t>(::strtol(cstr, &end, base));
 
-uint64_t
-StringExtractor::GetU64 (uint64_t fail_value, int base)
-{
-    if (m_index < m_packet.size())
-    {
-        char *end = nullptr;
-        const char *start = m_packet.c_str();
-        const char *cstr = start + m_index;
-        uint64_t result = ::strtoull (cstr, &end, base);
-        
-        if (end && end != cstr)
-        {
-            m_index = end - start;
-            return result;
-        }
+    if (end && end != cstr) {
+      m_index = end - start;
+      return result;
     }
-    return fail_value;
+  }
+  return fail_value;
 }
 
-int64_t
-StringExtractor::GetS64 (int64_t fail_value, int base)
-{
-    if (m_index < m_packet.size())
-    {
-        char *end = nullptr;
-        const char *start = m_packet.c_str();
-        const char *cstr = start + m_index;
-        int64_t result = ::strtoll (cstr, &end, base);
-        
-        if (end && end != cstr)
-        {
-            m_index = end - start;
-            return result;
-        }
+uint64_t StringExtractor::GetU64(uint64_t fail_value, int base) {
+  if (m_index < m_packet.size()) {
+    char *end = nullptr;
+    const char *start = m_packet.c_str();
+    const char *cstr = start + m_index;
+    uint64_t result = ::strtoull(cstr, &end, base);
+
+    if (end && end != cstr) {
+      m_index = end - start;
+      return result;
     }
-    return fail_value;
+  }
+  return fail_value;
 }
 
+int64_t StringExtractor::GetS64(int64_t fail_value, int base) {
+  if (m_index < m_packet.size()) {
+    char *end = nullptr;
+    const char *start = m_packet.c_str();
+    const char *cstr = start + m_index;
+    int64_t result = ::strtoll(cstr, &end, base);
 
-uint32_t
-StringExtractor::GetHexMaxU32 (bool little_endian, uint32_t fail_value)
-{
-    uint32_t result = 0;
-    uint32_t nibble_count = 0;
-
-    SkipSpaces();
-    if (little_endian)
-    {
-        uint32_t shift_amount = 0;
-        while (m_index < m_packet.size() && ::isxdigit (m_packet[m_index]))
-        {
-            // Make sure we don't exceed the size of a uint32_t...
-            if (nibble_count >= (sizeof(uint32_t) * 2))
-            {
-                m_index = UINT64_MAX;
-                return fail_value;
-            }
-
-            uint8_t nibble_lo;
-            uint8_t nibble_hi = xdigit_to_sint (m_packet[m_index]);
-            ++m_index;
-            if (m_index < m_packet.size() && ::isxdigit (m_packet[m_index]))
-            {
-                nibble_lo = xdigit_to_sint (m_packet[m_index]);
-                ++m_index;
-                result |= ((uint32_t)nibble_hi << (shift_amount + 4));
-                result |= ((uint32_t)nibble_lo << shift_amount);
-                nibble_count += 2;
-                shift_amount += 8;
-            }
-            else
-            {
-                result |= ((uint32_t)nibble_hi << shift_amount);
-                nibble_count += 1;
-                shift_amount += 4;
-            }
-
-        }
-    }
-    else
-    {
-        while (m_index < m_packet.size() && ::isxdigit (m_packet[m_index]))
-        {
-            // Make sure we don't exceed the size of a uint32_t...
-            if (nibble_count >= (sizeof(uint32_t) * 2))
-            {
-                m_index = UINT64_MAX;
-                return fail_value;
-            }
-
-            uint8_t nibble = xdigit_to_sint (m_packet[m_index]);
-            // Big Endian
-            result <<= 4;
-            result |= nibble;
-
-            ++m_index;
-            ++nibble_count;
-        }
+    if (end && end != cstr) {
+      m_index = end - start;
+      return result;
     }
-    return result;
+  }
+  return fail_value;
 }
 
-uint64_t
-StringExtractor::GetHexMaxU64 (bool little_endian, uint64_t fail_value)
-{
-    uint64_t result = 0;
-    uint32_t nibble_count = 0;
-
-    SkipSpaces();
-    if (little_endian)
-    {
-        uint32_t shift_amount = 0;
-        while (m_index < m_packet.size() && ::isxdigit (m_packet[m_index]))
-        {
-            // Make sure we don't exceed the size of a uint64_t...
-            if (nibble_count >= (sizeof(uint64_t) * 2))
-            {
-                m_index = UINT64_MAX;
-                return fail_value;
-            }
-
-            uint8_t nibble_lo;
-            uint8_t nibble_hi = xdigit_to_sint (m_packet[m_index]);
-            ++m_index;
-            if (m_index < m_packet.size() && ::isxdigit (m_packet[m_index]))
-            {
-                nibble_lo = xdigit_to_sint (m_packet[m_index]);
-                ++m_index;
-                result |= ((uint64_t)nibble_hi << (shift_amount + 4));
-                result |= ((uint64_t)nibble_lo << shift_amount);
-                nibble_count += 2;
-                shift_amount += 8;
-            }
-            else
-            {
-                result |= ((uint64_t)nibble_hi << shift_amount);
-                nibble_count += 1;
-                shift_amount += 4;
-            }
-
-        }
+uint32_t StringExtractor::GetHexMaxU32(bool little_endian,
+                                       uint32_t fail_value) {
+  uint32_t result = 0;
+  uint32_t nibble_count = 0;
+
+  SkipSpaces();
+  if (little_endian) {
+    uint32_t shift_amount = 0;
+    while (m_index < m_packet.size() && ::isxdigit(m_packet[m_index])) {
+      // Make sure we don't exceed the size of a uint32_t...
+      if (nibble_count >= (sizeof(uint32_t) * 2)) {
+        m_index = UINT64_MAX;
+        return fail_value;
+      }
+
+      uint8_t nibble_lo;
+      uint8_t nibble_hi = xdigit_to_sint(m_packet[m_index]);
+      ++m_index;
+      if (m_index < m_packet.size() && ::isxdigit(m_packet[m_index])) {
+        nibble_lo = xdigit_to_sint(m_packet[m_index]);
+        ++m_index;
+        result |= ((uint32_t)nibble_hi << (shift_amount + 4));
+        result |= ((uint32_t)nibble_lo << shift_amount);
+        nibble_count += 2;
+        shift_amount += 8;
+      } else {
+        result |= ((uint32_t)nibble_hi << shift_amount);
+        nibble_count += 1;
+        shift_amount += 4;
+      }
     }
-    else
-    {
-        while (m_index < m_packet.size() && ::isxdigit (m_packet[m_index]))
-        {
-            // Make sure we don't exceed the size of a uint64_t...
-            if (nibble_count >= (sizeof(uint64_t) * 2))
-            {
-                m_index = UINT64_MAX;
-                return fail_value;
-            }
-
-            uint8_t nibble = xdigit_to_sint (m_packet[m_index]);
-            // Big Endian
-            result <<= 4;
-            result |= nibble;
-
-            ++m_index;
-            ++nibble_count;
-        }
+  } else {
+    while (m_index < m_packet.size() && ::isxdigit(m_packet[m_index])) {
+      // Make sure we don't exceed the size of a uint32_t...
+      if (nibble_count >= (sizeof(uint32_t) * 2)) {
+        m_index = UINT64_MAX;
+        return fail_value;
+      }
+
+      uint8_t nibble = xdigit_to_sint(m_packet[m_index]);
+      // Big Endian
+      result <<= 4;
+      result |= nibble;
+
+      ++m_index;
+      ++nibble_count;
     }
-    return result;
+  }
+  return result;
 }
 
-size_t
-StringExtractor::GetHexBytes (llvm::MutableArrayRef<uint8_t> dest, uint8_t fail_fill_value)
-{
-    size_t bytes_extracted = 0;
-    while (!dest.empty() && GetBytesLeft() > 0)
-    {
-        dest[0] = GetHexU8 (fail_fill_value);
-        if (!IsGood())
-            break;
-        ++bytes_extracted;
-        dest = dest.drop_front();
+uint64_t StringExtractor::GetHexMaxU64(bool little_endian,
+                                       uint64_t fail_value) {
+  uint64_t result = 0;
+  uint32_t nibble_count = 0;
+
+  SkipSpaces();
+  if (little_endian) {
+    uint32_t shift_amount = 0;
+    while (m_index < m_packet.size() && ::isxdigit(m_packet[m_index])) {
+      // Make sure we don't exceed the size of a uint64_t...
+      if (nibble_count >= (sizeof(uint64_t) * 2)) {
+        m_index = UINT64_MAX;
+        return fail_value;
+      }
+
+      uint8_t nibble_lo;
+      uint8_t nibble_hi = xdigit_to_sint(m_packet[m_index]);
+      ++m_index;
+      if (m_index < m_packet.size() && ::isxdigit(m_packet[m_index])) {
+        nibble_lo = xdigit_to_sint(m_packet[m_index]);
+        ++m_index;
+        result |= ((uint64_t)nibble_hi << (shift_amount + 4));
+        result |= ((uint64_t)nibble_lo << shift_amount);
+        nibble_count += 2;
+        shift_amount += 8;
+      } else {
+        result |= ((uint64_t)nibble_hi << shift_amount);
+        nibble_count += 1;
+        shift_amount += 4;
+      }
     }
+  } else {
+    while (m_index < m_packet.size() && ::isxdigit(m_packet[m_index])) {
+      // Make sure we don't exceed the size of a uint64_t...
+      if (nibble_count >= (sizeof(uint64_t) * 2)) {
+        m_index = UINT64_MAX;
+        return fail_value;
+      }
+
+      uint8_t nibble = xdigit_to_sint(m_packet[m_index]);
+      // Big Endian
+      result <<= 4;
+      result |= nibble;
+
+      ++m_index;
+      ++nibble_count;
+    }
+  }
+  return result;
+}
 
-    if (!dest.empty())
-        ::memset(dest.data(), fail_fill_value, dest.size());
-
-    return bytes_extracted;
+size_t StringExtractor::GetHexBytes(llvm::MutableArrayRef<uint8_t> dest,
+                                    uint8_t fail_fill_value) {
+  size_t bytes_extracted = 0;
+  while (!dest.empty() && GetBytesLeft() > 0) {
+    dest[0] = GetHexU8(fail_fill_value);
+    if (!IsGood())
+      break;
+    ++bytes_extracted;
+    dest = dest.drop_front();
+  }
+
+  if (!dest.empty())
+    ::memset(dest.data(), fail_fill_value, dest.size());
+
+  return bytes_extracted;
 }
 
 //----------------------------------------------------------------------
@@ -381,134 +305,116 @@ StringExtractor::GetHexBytes (llvm::MutableArrayRef<uint8_t> dest, uint8_t fail_
 //
 // Returns the number of bytes successfully decoded
 //----------------------------------------------------------------------
-size_t
-StringExtractor::GetHexBytesAvail (llvm::MutableArrayRef<uint8_t> dest)
-{
-    size_t bytes_extracted = 0;
-    while (!dest.empty())
-    {
-        int decode = DecodeHexU8();
-        if (decode == -1)
-            break;
-        dest[0] = (uint8_t)decode;
-        dest = dest.drop_front();
-        ++bytes_extracted;
-    }
-    return bytes_extracted;
+size_t StringExtractor::GetHexBytesAvail(llvm::MutableArrayRef<uint8_t> dest) {
+  size_t bytes_extracted = 0;
+  while (!dest.empty()) {
+    int decode = DecodeHexU8();
+    if (decode == -1)
+      break;
+    dest[0] = (uint8_t)decode;
+    dest = dest.drop_front();
+    ++bytes_extracted;
+  }
+  return bytes_extracted;
 }
 
 // Consume ASCII hex nibble character pairs until we have decoded byte_size
 // bytes of data.
 
-uint64_t
-StringExtractor::GetHexWithFixedSize (uint32_t byte_size, bool little_endian, uint64_t fail_value)
-{
-    if (byte_size <= 8 && GetBytesLeft() >= byte_size * 2)
-    {
-        uint64_t result = 0;
-        uint32_t i;
-        if (little_endian)
-        {
-            // Little Endian
-            uint32_t shift_amount;
-            for (i = 0, shift_amount = 0;
-                 i < byte_size && IsGood();
-                 ++i, shift_amount += 8)
-            {
-                result |= ((uint64_t)GetHexU8() << shift_amount);
-            }
-        }
-        else
-        {
-            // Big Endian
-            for (i = 0; i < byte_size && IsGood(); ++i)
-            {
-                result <<= 8;
-                result |= GetHexU8();
-            }
-        }
+uint64_t StringExtractor::GetHexWithFixedSize(uint32_t byte_size,
+                                              bool little_endian,
+                                              uint64_t fail_value) {
+  if (byte_size <= 8 && GetBytesLeft() >= byte_size * 2) {
+    uint64_t result = 0;
+    uint32_t i;
+    if (little_endian) {
+      // Little Endian
+      uint32_t shift_amount;
+      for (i = 0, shift_amount = 0; i < byte_size && IsGood();
+           ++i, shift_amount += 8) {
+        result |= ((uint64_t)GetHexU8() << shift_amount);
+      }
+    } else {
+      // Big Endian
+      for (i = 0; i < byte_size && IsGood(); ++i) {
+        result <<= 8;
+        result |= GetHexU8();
+      }
     }
-    m_index = UINT64_MAX;
-    return fail_value;
+  }
+  m_index = UINT64_MAX;
+  return fail_value;
 }
 
-size_t
-StringExtractor::GetHexByteString (std::string &str)
-{
-    str.clear();
-    str.reserve(GetBytesLeft() / 2);
-    char ch;
-    while ((ch = GetHexU8()) != '\0')
-        str.append(1, ch);
-    return str.size();
+size_t StringExtractor::GetHexByteString(std::string &str) {
+  str.clear();
+  str.reserve(GetBytesLeft() / 2);
+  char ch;
+  while ((ch = GetHexU8()) != '\0')
+    str.append(1, ch);
+  return str.size();
 }
 
-size_t
-StringExtractor::GetHexByteStringFixedLength (std::string &str, uint32_t nibble_length)
-{
-    str.clear();
+size_t StringExtractor::GetHexByteStringFixedLength(std::string &str,
+                                                    uint32_t nibble_length) {
+  str.clear();
 
-    uint32_t nibble_count = 0;
-    for (const char *pch = Peek(); (nibble_count < nibble_length) && (pch != nullptr); str.append(1, GetHexU8(0, false)), pch = Peek (), nibble_count += 2)
-    {}
+  uint32_t nibble_count = 0;
+  for (const char *pch = Peek();
+       (nibble_count < nibble_length) && (pch != nullptr);
+       str.append(1, GetHexU8(0, false)), pch = Peek(), nibble_count += 2) {
+  }
 
-    return str.size();
+  return str.size();
 }
 
-size_t
-StringExtractor::GetHexByteStringTerminatedBy (std::string &str,
-                                               char terminator)
-{
-    str.clear();
-    char ch;
-    while ((ch = GetHexU8(0,false)) != '\0')
-        str.append(1, ch);
-    if (Peek() && *Peek() == terminator)
-        return str.size();
-
-    str.clear();
+size_t StringExtractor::GetHexByteStringTerminatedBy(std::string &str,
+                                                     char terminator) {
+  str.clear();
+  char ch;
+  while ((ch = GetHexU8(0, false)) != '\0')
+    str.append(1, ch);
+  if (Peek() && *Peek() == terminator)
     return str.size();
-}
 
-bool
-StringExtractor::GetNameColonValue(llvm::StringRef &name, llvm::StringRef &value)
-{
-    // Read something in the form of NNNN:VVVV; where NNNN is any character
-    // that is not a colon, followed by a ':' character, then a value (one or
-    // more ';' chars), followed by a ';'
-    if (m_index >= m_packet.size())
-        return fail();
-
-    llvm::StringRef view(m_packet);
-    if (view.empty())
-        return fail();
-
-    llvm::StringRef a, b, c, d;
-    view = view.substr(m_index);
-    std::tie(a, b) = view.split(':');
-    if (a.empty() || b.empty())
-        return fail();
-    std::tie(c, d) = b.split(';');
-    if (b == c && d.empty())
-        return fail();
-
-    name = a;
-    value = c;
-    if (d.empty())
-        m_index = m_packet.size();
-    else
-    {
-        size_t bytes_consumed = d.data() - view.data();
-        m_index += bytes_consumed;
-    }
-    return true;
+  str.clear();
+  return str.size();
 }
 
-void
-StringExtractor::SkipSpaces ()
-{
-    const size_t n = m_packet.size();
-    while (m_index < n && isspace(m_packet[m_index]))
-        ++m_index;
+bool StringExtractor::GetNameColonValue(llvm::StringRef &name,
+                                        llvm::StringRef &value) {
+  // Read something in the form of NNNN:VVVV; where NNNN is any character
+  // that is not a colon, followed by a ':' character, then a value (one or
+  // more ';' chars), followed by a ';'
+  if (m_index >= m_packet.size())
+    return fail();
+
+  llvm::StringRef view(m_packet);
+  if (view.empty())
+    return fail();
+
+  llvm::StringRef a, b, c, d;
+  view = view.substr(m_index);
+  std::tie(a, b) = view.split(':');
+  if (a.empty() || b.empty())
+    return fail();
+  std::tie(c, d) = b.split(';');
+  if (b == c && d.empty())
+    return fail();
+
+  name = a;
+  value = c;
+  if (d.empty())
+    m_index = m_packet.size();
+  else {
+    size_t bytes_consumed = d.data() - view.data();
+    m_index += bytes_consumed;
+  }
+  return true;
 }
 
+void StringExtractor::SkipSpaces() {
+  const size_t n = m_packet.size();
+  while (m_index < n && isspace(m_packet[m_index]))
+    ++m_index;
+}