[ADT] Replace std::isprint by llvm::isPrint.

[Meinersbur]

Summary

The standard library functions isprint/std::isprint have platform- and locale-dependent behavior which makes LLVM's output less predictable. In particular, regression tests my fail depending on the implementation of these functions.

Implement llvm::isPrint in StringExtras.h with a standard behavior and replace all uses of isprint/std::isprint by a call it llvm::isPrint. The function is inlined and does not look up language settings so it should perform better than the standard library's version.

Such a replacement has already been done for isdigit, isalpha, isxdigit in r314883. gtest does the same in gtest-printers.cc using the following justification:

// Returns true if c is a printable ASCII character.  We test the
// value of c directly instead of calling isprint(), which is buggy on
// Windows Mobile.
inline bool IsPrintableAscii(wchar_t c) {
  return 0x20 <= c && c <= 0x7E;
}

Similar issues have also been encountered by Julia: https://github.com/JuliaLang/julia/issues/7416

I noticed the problem myself when on Windows isprint('\t') started to evaluate to true (see https://stackoverflow.com/questions/51435249) and thus caused several unit tests to fail. The result of isprint doesn't seem to be well-defined even for ASCII characters. Therefore I suggest to replace isprint by a system-independent version.

[Bigcheese]

lgtm

[Meinersbur]

Rebase to r338031 before commit

llvm/trunk/include/llvm/ADT/StringExtras.h

 /// Checks whether all characters in S are ASCII.
 inline bool isASCII(llvm::StringRef S) {
   for (char C : S)
     if (LLVM_UNLIKELY(!isASCII(C)))
       return false;
   return true;
 }
 
+/// Checks whether character \p C is printable.
+///
+/// Locale-independent version of the C standard library isprint whose results
+/// may differ on different platforms.
+inline bool isPrint(char C) {
+  unsigned char UC = static_cast<unsigned char>(C);
+  return (0x20 <= UC) && (UC <= 0x7E);
+}
+
 /// Returns the corresponding lowercase character if \p x is uppercase.
 inline char toLower(char x) {
   if (x >= 'A' && x <= 'Z')
     return x - 'A' + 'a';
   return x;
 }
 
 /// Returns the corresponding uppercase character if \p x is lowercase.

llvm/trunk/include/llvm/Support/raw_ostream.h

public:
   /// Output \p N in hexadecimal, without any prefix or padding.
   raw_ostream &write_hex(unsigned long long N);
 
   /// Output a formatted UUID with dash separators.
   using uuid_t = uint8_t[16];
   raw_ostream &write_uuid(const uuid_t UUID);
 
   /// Output \p Str, turning '\\', '\t', '\n', '"', and anything that doesn't
-  /// satisfy std::isprint into an escape sequence.
+  /// satisfy llvm::isPrint into an escape sequence.
   raw_ostream &write_escaped(StringRef Str, bool UseHexEscapes = false);
 
   raw_ostream &write(unsigned char C);
   raw_ostream &write(const char *Ptr, size_t Size);
 
   // Formatted output, see the format() function in Support/Format.h.
   raw_ostream &operator<<(const format_object_base &Fmt);
 

llvm/trunk/lib/MC/MCAsmStreamer.cpp

static void PrintQuotedString(StringRef Data, raw_ostream &OS) {
 
   for (unsigned i = 0, e = Data.size(); i != e; ++i) {
     unsigned char C = Data[i];
     if (C == '"' || C == '\\') {
       OS << '\\' << (char)C;
       continue;
     }
 
-    if (isprint((unsigned char)C)) {
+    if (isPrint((unsigned char)C)) {
       OS << (char)C;
       continue;
     }
 
     switch (C) {
       case '\b': OS << "\\b"; break;
       case '\f': OS << "\\f"; break;
       case '\n': OS << "\\n"; break;

llvm/trunk/lib/ProfileData/InstrProfReader.cpp

 
 bool TextInstrProfReader::hasFormat(const MemoryBuffer &Buffer) {
   // Verify that this really looks like plain ASCII text by checking a
   // 'reasonable' number of characters (up to profile magic size).
   size_t count = std::min(Buffer.getBufferSize(), sizeof(uint64_t));
   StringRef buffer = Buffer.getBufferStart();
   return count == 0 ||
          std::all_of(buffer.begin(), buffer.begin() + count,
-                     [](char c) { return ::isprint(c) || ::isspace(c); });
+                     [](char c) { return isPrint(c) || ::isspace(c); });
 }
 
 // Read the profile variant flag from the header: ":FE" means this is a FE
 // generated profile. ":IR" means this is an IR level profile. Other strings
 // with a leading ':' will be reported an error format.
 Error TextInstrProfReader::readHeader() {
   Symtab.reset(new InstrProfSymtab());
   bool IsIRInstr = false;

llvm/trunk/lib/Support/StringExtras.cpp

while (!S.first.empty()) {
     OutFragments.push_back(S.first);
     S = getToken(S.second, Delimiters);
   }
 }
 
 void llvm::printEscapedString(StringRef Name, raw_ostream &Out) {
   for (unsigned i = 0, e = Name.size(); i != e; ++i) {
     unsigned char C = Name[i];
-    if (isprint(C) && C != '\\' && C != '"')
+    if (isPrint(C) && C != '\\' && C != '"')
       Out << C;
     else
       Out << '\\' << hexdigit(C >> 4) << hexdigit(C & 0x0F);
   }
 }
 
 void llvm::printHTMLEscaped(StringRef String, raw_ostream &Out) {
   for (char C : String) {

llvm/trunk/lib/Support/raw_ostream.cpp

case '\t':
       break;
     case '\n':
       *this << '\\' << 'n';
       break;
     case '"':
       *this << '\\' << '"';
       break;
     default:
-      if (std::isprint(c)) {
+      if (isPrint(c)) {
         *this << c;
         break;
       }
 
       // Write out the escaped representation.
       if (UseHexEscapes) {
         *this << '\\' << 'x';
         *this << hexdigit((c >> 4 & 0xF));
if (FB.ASCII) {
       // Print any spaces needed for any bytes that we didn't print on this
       // line so that the ASCII bytes are correctly aligned.
       assert(BlockCharWidth >= CharsPrinted);
       indent(BlockCharWidth - CharsPrinted + 2);
       *this << "|";
 
       // Print the ASCII char values for each byte on this line
       for (uint8_t Byte : Line) {
-        if (isprint(Byte))
+        if (isPrint(Byte))
           *this << static_cast<char>(Byte);
         else
           *this << '.';
       }
       *this << '|';
     }
 
     Bytes = Bytes.drop_front(Line.size());

llvm/trunk/lib/Support/regengine.inc

  * a matching debug.o, and this is convenient.  It all disappears in
  * the non-debug compilation anyway, so it doesn't matter much.
  */
 static char *     /* -> representation */
 pchar(int ch)
 {
   static char pbuf[10];
 
-  if (isprint(ch) || ch == ' ')
+  if (isPrint(ch) || ch == ' ')
     (void)snprintf(pbuf, sizeof pbuf, "%c", ch);
   else
     (void)snprintf(pbuf, sizeof pbuf, "\\%o", ch);
   return(pbuf);
 }
 #endif
 #endif
 

llvm/trunk/tools/llvm-bcanalyzer/llvm-bcanalyzer.cpp

if (DumpRecords) {
         for (unsigned i = 1, e = Abbv->getNumOperandInfos(); i != e; ++i) {
           const BitCodeAbbrevOp &Op = Abbv->getOperandInfo(i);
           if (!Op.isEncoding() || Op.getEncoding() != BitCodeAbbrevOp::Array)
             continue;
           assert(i + 2 == e && "Array op not second to last");
           std::string Str;
           bool ArrayIsPrintable = true;
           for (unsigned j = i - 1, je = Record.size(); j != je; ++j) {
-            if (!isprint(static_cast<unsigned char>(Record[j]))) {
+            if (!isPrint(static_cast<unsigned char>(Record[j]))) {
               ArrayIsPrintable = false;
               break;
             }
             Str += (char)Record[j];
           }
           if (ArrayIsPrintable)
             outs() << " record string = '" << Str << "'";
           break;
         }
       }
 
       if (Blob.data() && decodeBlob(Code, BlockID, Indent, Record, Blob)) {
         outs() << " blob data = ";
         if (ShowBinaryBlobs) {
           outs() << "'";
           outs().write_escaped(Blob, /*hex=*/true) << "'";
         } else {
           bool BlobIsPrintable = true;
           for (unsigned i = 0, e = Blob.size(); i != e; ++i)
-            if (!isprint(static_cast<unsigned char>(Blob[i]))) {
+            if (!isPrint(static_cast<unsigned char>(Blob[i]))) {
               BlobIsPrintable = false;
               break;
             }
 
           if (BlobIsPrintable)
             outs() << "'" << Blob << "'";
           else
             outs() << "unprintable, " << Blob.size() << " bytes.";          

llvm/trunk/tools/llvm-objdump/llvm-objdump.cpp

#endif
                 ((SectionAddr + Index) > StopAddress))
               continue;
             if (NumBytes == 0) {
               outs() << format("%8" PRIx64 ":", SectionAddr + Index);
               outs() << "\t";
             }
             Byte = Bytes.slice(Index)[0];
             outs() << format(" %02x", Byte);
-            AsciiData[NumBytes] = isprint(Byte) ? Byte : '.';
+            AsciiData[NumBytes] = isPrint(Byte) ? Byte : '.';
 
             uint8_t IndentOffset = 0;
             NumBytes++;
             if (Index == End - 1 || NumBytes > 8) {
               // Indent the space for less than 8 bytes data.
               // 2 spaces for byte and one for space between bytes
               IndentOffset = 3 * (8 - NumBytes);
               for (int Excess = 8 - NumBytes; Excess < 8; Excess++)
for (std::size_t addr = 0, end = Contents.size(); addr < end; addr += 16) {
           outs() << hexdigit((Contents[addr + i] >> 4) & 0xF, true)
                  << hexdigit(Contents[addr + i] & 0xF, true);
         else
           outs() << "  ";
       }
       // Print ascii.
       outs() << "  ";
       for (std::size_t i = 0; i < 16 && addr + i < end; ++i) {
-        if (std::isprint(static_cast<unsigned char>(Contents[addr + i]) & 0xFF))
+        if (isPrint(static_cast<unsigned char>(Contents[addr + i]) & 0xFF))
           outs() << Contents[addr + i];
         else
           outs() << ".";
       }
       outs() << "\n";
     }
   }
 }

llvm/trunk/tools/llvm-readobj/ObjDumper.cpp

 
 ObjDumper::ObjDumper(ScopedPrinter &Writer) : W(Writer) {}
 
 ObjDumper::~ObjDumper() {
 }
 
 static void printAsPrintable(raw_ostream &W, const uint8_t *Start, size_t Len) {
   for (size_t i = 0; i < Len; i++)
-    W << (isprint(Start[i]) ? static_cast<char>(Start[i]) : '.');
+    W << (isPrint(Start[i]) ? static_cast<char>(Start[i]) : '.');
 }
 
 static Expected<object::SectionRef>
 getSecNameOrIndexAsSecRef(const object::ObjectFile *Obj, StringRef SecName) {
   char *StrPtr;
   long SectionIndex = strtol(SecName.data(), &StrPtr, 10);
   object::SectionRef Section;
   long SecIndex;
for (const uint8_t *SecPtr = SecContent; SecPtr < SecEnd; SecPtr += 16) {
     // Least, if we cut in a middle of a row, we add the remaining characters,
     // which is (8 - (k * 2))
     if (i < 4)
       W.startLine() << format("%*c", (4 - i) * 8 + (4 - i) + (8 - (k * 2)),
                               ' ');
 
     TmpSecPtr = SecPtr;
     for (i = 0; TmpSecPtr + i < SecEnd && i < 16; ++i)
-      W.startLine() << (isprint(TmpSecPtr[i]) ? static_cast<char>(TmpSecPtr[i])
+      W.startLine() << (isPrint(TmpSecPtr[i]) ? static_cast<char>(TmpSecPtr[i])
                                               : '.');
 
     W.startLine() << '\n';
   }
 }
 
 } // namespace llvm

llvm/trunk/unittests/ADT/StringExtrasTest.cpp

 //===- StringExtrasTest.cpp - Unit tests for String extras ----------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/Support/raw_ostream.h"
 #include "gtest/gtest.h"
 
 using namespace llvm;
 
+TEST(StringExtrasTest, isPrint) {
+  EXPECT_FALSE(isPrint('\0'));
+  EXPECT_FALSE(isPrint('\t'));
+  EXPECT_TRUE(isPrint('0'));
+  EXPECT_TRUE(isPrint('a'));
+  EXPECT_TRUE(isPrint('A'));
+  EXPECT_TRUE(isPrint(' '));
+  EXPECT_TRUE(isPrint('~'));
+  EXPECT_TRUE(isPrint('?'));
+}
+
 TEST(StringExtrasTest, Join) {
   std::vector<std::string> Items;
   EXPECT_EQ("", join(Items.begin(), Items.end(), " <sep> "));
 
   Items = {"foo"};
   EXPECT_EQ("foo", join(Items.begin(), Items.end(), " <sep> "));
 
   Items = {"foo", "bar"};

 
 TEST(StringExtrasTest, printLowerCase) {
   std::string str;
   raw_string_ostream OS(str);
   printLowerCase("ABCdefg01234.,&!~`'}\"", OS);
   EXPECT_EQ("abcdefg01234.,&!~`'}\"", OS.str());
 }
 
+TEST(StringExtrasTest, printEscapedString) {
+  std::string str;
+  raw_string_ostream OS(str);
+  printEscapedString("ABCdef123&<>\\\"'\t", OS);
+  EXPECT_EQ("ABCdef123&<>\\5C\\22'\\09", OS.str());
+}
+
 TEST(StringExtrasTest, printHTMLEscaped) {
   std::string str;
   raw_string_ostream OS(str);
   printHTMLEscaped("ABCdef123&<>\"'", OS);
   EXPECT_EQ("ABCdef123&amp;&lt;&gt;&quot;&apos;", OS.str());
 }