[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/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/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) && isspace(c) == 0) {
               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())));
 }