contrib/llvm/tools/clang/lib/Format/Encoding.h

   1 //===--- Encoding.h - Format C++ code ---------------------------*- C++ -*-===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 ///
   9 /// \file
  10 /// Contains functions for text encoding manipulation. Supports UTF-8,
  11 /// 8-bit encodings and escape sequences in C++ string literals.
  12 ///
  13 //===----------------------------------------------------------------------===//
  14
  15 #ifndef LLVM_CLANG_LIB_FORMAT_ENCODING_H
  16 #define LLVM_CLANG_LIB_FORMAT_ENCODING_H
  17
  18 #include "clang/Basic/LLVM.h"
  19 #include "llvm/ADT/StringRef.h"
  20 #include "llvm/Support/ConvertUTF.h"
  21 #include "llvm/Support/Unicode.h"
  22
  23 namespace clang {
  24 namespace format {
  25 namespace encoding {
  26
  27 enum Encoding {
  28   Encoding_UTF8,
  29   Encoding_Unknown // We treat all other encodings as 8-bit encodings.
  30 };
  31
  32 /// Detects encoding of the Text. If the Text can be decoded using UTF-8,
  33 /// it is considered UTF8, otherwise we treat it as some 8-bit encoding.
  34 inline Encoding detectEncoding(StringRef Text) {
  35   const llvm::UTF8 *Ptr = reinterpret_cast<const llvm::UTF8 *>(Text.begin());
  36   const llvm::UTF8 *BufEnd = reinterpret_cast<const llvm::UTF8 *>(Text.end());
  37   if (llvm::isLegalUTF8String(&Ptr, BufEnd))
  38     return Encoding_UTF8;
  39   return Encoding_Unknown;
  40 }
  41
  42 /// Returns the number of columns required to display the \p Text on a
  43 /// generic Unicode-capable terminal. Text is assumed to use the specified
  44 /// \p Encoding.
  45 inline unsigned columnWidth(StringRef Text, Encoding Encoding) {
  46   if (Encoding == Encoding_UTF8) {
  47     int ContentWidth = llvm::sys::unicode::columnWidthUTF8(Text);
  48     // FIXME: Figure out the correct way to handle this in the presence of both
  49     // printable and unprintable multi-byte UTF-8 characters. Falling back to
  50     // returning the number of bytes may cause problems, as columnWidth suddenly
  51     // becomes non-additive.
  52     if (ContentWidth >= 0)
  53       return ContentWidth;
  54   }
  55   return Text.size();
  56 }
  57
  58 /// Returns the number of columns required to display the \p Text,
  59 /// starting from the \p StartColumn on a terminal with the \p TabWidth. The
  60 /// text is assumed to use the specified \p Encoding.
  61 inline unsigned columnWidthWithTabs(StringRef Text, unsigned StartColumn,
  62                                     unsigned TabWidth, Encoding Encoding) {
  63   unsigned TotalWidth = 0;
  64   StringRef Tail = Text;
  65   for (;;) {
  66     StringRef::size_type TabPos = Tail.find('\t');
  67     if (TabPos == StringRef::npos)
  68       return TotalWidth + columnWidth(Tail, Encoding);
  69     TotalWidth += columnWidth(Tail.substr(0, TabPos), Encoding);
  70     TotalWidth += TabWidth - (TotalWidth + StartColumn) % TabWidth;
  71     Tail = Tail.substr(TabPos + 1);
  72   }
  73 }
  74
  75 /// Gets the number of bytes in a sequence representing a single
  76 /// codepoint and starting with FirstChar in the specified Encoding.
  77 inline unsigned getCodePointNumBytes(char FirstChar, Encoding Encoding) {
  78   switch (Encoding) {
  79   case Encoding_UTF8:
  80     return llvm::getNumBytesForUTF8(FirstChar);
  81   default:
  82     return 1;
  83   }
  84 }
  85
  86 inline bool isOctDigit(char c) { return '0' <= c && c <= '7'; }
  87
  88 inline bool isHexDigit(char c) {
  89   return ('0' <= c && c <= '9') || ('a' <= c && c <= 'f') ||
  90          ('A' <= c && c <= 'F');
  91 }
  92
  93 /// Gets the length of an escape sequence inside a C++ string literal.
  94 /// Text should span from the beginning of the escape sequence (starting with a
  95 /// backslash) to the end of the string literal.
  96 inline unsigned getEscapeSequenceLength(StringRef Text) {
  97   assert(Text[0] == '\\');
  98   if (Text.size() < 2)
  99     return 1;
 100
 101   switch (Text[1]) {
 102   case 'u':
 103     return 6;
 104   case 'U':
 105     return 10;
 106   case 'x': {
 107     unsigned I = 2; // Point after '\x'.
 108     while (I < Text.size() && isHexDigit(Text[I]))
 109       ++I;
 110     return I;
 111   }
 112   default:
 113     if (isOctDigit(Text[1])) {
 114       unsigned I = 1;
 115       while (I < Text.size() && I < 4 && isOctDigit(Text[I]))
 116         ++I;
 117       return I;
 118     }
 119     return 1 + llvm::getNumBytesForUTF8(Text[1]);
 120   }
 121 }
 122
 123 } // namespace encoding
 124 } // namespace format
 125 } // namespace clang
 126
 127 #endif