[lldb] Replace std::isprint/isspace with llvm's locale-independent version

[teemperor]

Summary

LLVM is using its own isPrint/isSpace implementation that doesn't change depending on the current locale. LLDB should do the same
to prevent that internal logic changes depending on the set locale.

[totally_not_teemperor]

• Also replace isspace

[JDevlieghere]

Not sure I can trust @totally_not_teemperor but the change LGTM

lldb/include/lldb/Interpreter/Options.h

struct OptionArgElement {
   int opt_arg_pos;
 };
 
 typedef std::vector<OptionArgElement> OptionElementVector;
 
 static inline bool isprint8(int ch) {
   if (ch & 0xffffff00u)
     return false;
-  return isprint(ch);
+  return llvm::isPrint(ch);
 }
 
 /// \class Options Options.h "lldb/Interpreter/Options.h"
 /// A command line option parsing protocol class.
 ///
 /// Options is designed to be subclassed to contain all needed options for a
 /// given command. The options can be parsed by calling the Parse function.
 ///

lldb/source/Core/DumpDataExtractor.cpp

case eFormatCharArray: {
       }
 
       // If we are only printing one character surround it with single quotes
       if (item_count == 1 && item_format == eFormatChar)
         s->PutChar('\'');
 
       const uint64_t ch = DE.GetMaxU64Bitfield(&offset, item_byte_size,
                                                item_bit_size, item_bit_offset);
-      if (isprint(ch))
+      if (llvm::isPrint(ch))
         s->Printf("%c", (char)ch);
       else if (item_format != eFormatCharPrintable) {
         switch (ch) {
         case '\033':
           s->Printf("\\e");
           break;
         case '\a':
           s->Printf("\\a");
case eFormatOctal:
       break;
 
     case eFormatOSType: {
       uint64_t uval64 = DE.GetMaxU64Bitfield(&offset, item_byte_size,
                                              item_bit_size, item_bit_offset);
       s->PutChar('\'');
       for (uint32_t i = 0; i < item_byte_size; ++i) {
         uint8_t ch = (uint8_t)(uval64 >> ((item_byte_size - i - 1) * 8));
-        if (isprint(ch))
+        if (llvm::isPrint(ch))
           s->Printf("%c", ch);
         else {
           switch (ch) {
           case '\033':
             s->Printf("\\e");
             break;
           case '\a':
             s->Printf("\\a");
case eFormatCString: {
 
       if (!cstr) {
         s->Printf("NULL");
         offset = LLDB_INVALID_OFFSET;
       } else {
         s->PutChar('\"');
 
         while (const char c = *cstr) {
-          if (isprint(c)) {
+          if (llvm::isPrint(c)) {
             s->PutChar(c);
           } else {
             switch (c) {
             case '\033':
               s->Printf("\\e");
               break;
             case '\a':
               s->Printf("\\a");

lldb/source/Core/IOHandler.cpp

std::string line =
       std::string(StringRef(line_buffer.c_str(), pos).rtrim("\n\r"));
   line_buffer = line_buffer.substr(pos + 1);
   return line;
 }
 
 // If the final line of the file ends without a end-of-line, return
 // it as a line anyway.
 static Optional<std::string> SplitLineEOF(std::string &line_buffer) {
-  if (llvm::all_of(line_buffer, isspace))
+  if (llvm::all_of(line_buffer, llvm::isSpace))
     return None;
   std::string line = std::move(line_buffer);
   line_buffer.clear();
   return line;
 }
 
 bool IOHandlerEditline::GetLine(std::string &line, bool &interrupted) {
 #if LLDB_ENABLE_LIBEDIT

lldb/source/Core/IOHandlerCursesGUI.cpp

if (m_type == Type::Separator) {
     }
     window.PutChar(ACS_RTEE);
   } else {
     const int shortcut_key = m_key_value;
     bool underlined_shortcut = false;
     const attr_t hilgight_attr = A_REVERSE;
     if (highlight)
       window.AttributeOn(hilgight_attr);
-    if (isprint(shortcut_key)) {
+    if (llvm::isPrint(shortcut_key)) {
       size_t lower_pos = m_name.find(tolower(shortcut_key));
       size_t upper_pos = m_name.find(toupper(shortcut_key));
       const char *name = m_name.c_str();
       size_t pos = std::min<size_t>(lower_pos, upper_pos);
       if (pos != std::string::npos) {
         underlined_shortcut = true;
         if (pos > 0) {
           window.PutCString(name, pos);
if (m_type == Type::Separator) {
     if (!underlined_shortcut) {
       window.PutCString(m_name.c_str());
     }
 
     if (highlight)
       window.AttributeOff(hilgight_attr);
 
     if (m_key_name.empty()) {
-      if (!underlined_shortcut && isprint(m_key_value)) {
+      if (!underlined_shortcut && llvm::isPrint(m_key_value)) {
         window.AttributeOn(COLOR_PAIR(3));
         window.Printf(" (%c)", m_key_value);
         window.AttributeOff(COLOR_PAIR(3));
       }
     } else {
       window.AttributeOn(COLOR_PAIR(3));
       window.Printf(" (%s)", m_key_name.c_str());
       window.AttributeOff(COLOR_PAIR(3));
case KEY_RETURN:
     return "return";
   case ' ':
     return "space";
   case '\t':
     return "tab";
   case KEY_ESCAPE:
     return "escape";
   default:
-    if (isprint(ch))
+    if (llvm::isPrint(ch))
       snprintf(g_desc, sizeof(g_desc), "%c", ch);
     else
       snprintf(g_desc, sizeof(g_desc), "\\x%2.2x", ch);
     return g_desc;
   }
   return nullptr;
 }
 

lldb/source/Interpreter/CommandInterpreter.cpp

 static size_t FindArgumentTerminator(const std::string &s) {
   const size_t s_len = s.size();
   size_t offset = 0;
   while (offset < s_len) {
     size_t pos = s.find("--", offset);
     if (pos == std::string::npos)
       break;
     if (pos > 0) {
-      if (isspace(s[pos - 1])) {
+      if (llvm::isSpace(s[pos - 1])) {
         // Check if the string ends "\s--" (where \s is a space character) or
         // if we have "\s--\s".
-        if ((pos + 2 >= s_len) || isspace(s[pos + 2])) {
+        if ((pos + 2 >= s_len) || llvm::isSpace(s[pos + 2])) {
           return pos;
         }
       }
     }
     offset = pos + 2;
   }
   return std::string::npos;
 }

lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunication.cpp

if (content_length == std::string::npos) {
           m_history.Dump(log);
 
         bool binary = false;
         // Only detect binary for packets that start with a '$' and have a
         // '#CC' checksum
         if (m_bytes[0] == '$' && total_length > 4) {
           for (size_t i = 0; !binary && i < total_length; ++i) {
             unsigned char c = m_bytes[i];
-            if (isprint(c) == 0 && isspace(c) == 0) {
+            if (!llvm::isPrint(c) && !llvm::isSpace(c)) {
               binary = true;
             }
           }
         }
         if (binary) {
           StreamString strm;
           // Packet header...
           if (CompressionIsEnabled())

lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.cpp

 
 int GDBRemoteCommunicationClient::SendEnvironmentPacket(
     char const *name_equal_value) {
   if (name_equal_value && name_equal_value[0]) {
     StreamString packet;
     bool send_hex_encoding = false;
     for (const char *p = name_equal_value; *p != '\0' && !send_hex_encoding;
          ++p) {
-      if (isprint(*p)) {
+      if (llvm::isPrint(*p)) {
         switch (*p) {
         case '$':
         case '#':
         case '*':
         case '}':
           send_hex_encoding = true;
           break;
         default:

lldb/source/Utility/Args.cpp

if (src) {
     }
   }
 }
 
 void Args::ExpandEscapedCharacters(const char *src, std::string &dst) {
   dst.clear();
   if (src) {
     for (const char *p = src; *p != '\0'; ++p) {
-      if (isprint(*p))
+      if (llvm::isPrint(*p))
         dst.append(1, *p);
       else {
         switch (*p) {
         case '\a':
           dst.append("\\a");
           break;
         case '\b':
           dst.append("\\b");

lldb/source/Utility/DataExtractor.cpp

for (offset = start_offset, end_offset = offset + length, count = 0;
     }
 
     switch (type) {
     case TypeUInt8:
       sstr.Printf(" %2.2x", GetU8(&offset));
       break;
     case TypeChar: {
       char ch = GetU8(&offset);
-      sstr.Printf(" %c", isprint(ch) ? ch : ' ');
+      sstr.Printf(" %c", llvm::isPrint(ch) ? ch : ' ');
     } break;
     case TypeUInt16:
       sstr.Printf(" %4.4x", GetU16(&offset));
       break;
     case TypeUInt32:
       sstr.Printf(" %8.8x", GetU32(&offset));
       break;
     case TypeUInt64:

lldb/source/Utility/Event.cpp

 }
 
 ConstString EventDataBytes::GetFlavor() const {
   return EventDataBytes::GetFlavorString();
 }
 
 void EventDataBytes::Dump(Stream *s) const {
   size_t num_printable_chars =
-      std::count_if(m_bytes.begin(), m_bytes.end(), isprint);
+      std::count_if(m_bytes.begin(), m_bytes.end(), llvm::isPrint);
   if (num_printable_chars == m_bytes.size())
     s->Format("\"{0}\"", m_bytes);
   else
     s->Format("{0:$[ ]@[x-2]}", llvm::make_range(
                          reinterpret_cast<const uint8_t *>(m_bytes.data()),
                          reinterpret_cast<const uint8_t *>(m_bytes.data() +
                                                            m_bytes.size())));
 }

lldb/source/Utility/StringExtractor.cpp

 //===-- StringExtractor.cpp -----------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Utility/StringExtractor.h"
+#include "llvm/ADT/StringExtras.h"
 
 #include <tuple>
 
 #include <ctype.h>
 #include <stdlib.h>
 #include <string.h>
 
 static inline int xdigit_to_sint(char ch) {
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]))
+  while (m_index < n && llvm::isSpace(m_packet[m_index]))
     ++m_index;
 }