Home | History | Annotate | Line # | Download | only in Format
Encoding.h revision 1.1 
      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     if (TabWidth)
     71       TotalWidth += TabWidth - (TotalWidth + StartColumn) % TabWidth;
     72     Tail = Tail.substr(TabPos + 1);
     73   }
     74 }
     75 
     76 /// Gets the number of bytes in a sequence representing a single
     77 /// codepoint and starting with FirstChar in the specified Encoding.
     78 inline unsigned getCodePointNumBytes(char FirstChar, Encoding Encoding) {
     79   switch (Encoding) {
     80   case Encoding_UTF8:
     81     return llvm::getNumBytesForUTF8(FirstChar);
     82   default:
     83     return 1;
     84   }
     85 }
     86 
     87 inline bool isOctDigit(char c) { return '0' <= c && c <= '7'; }
     88 
     89 inline bool isHexDigit(char c) {
     90   return ('0' <= c && c <= '9') || ('a' <= c && c <= 'f') ||
     91          ('A' <= c && c <= 'F');
     92 }
     93 
     94 /// Gets the length of an escape sequence inside a C++ string literal.
     95 /// Text should span from the beginning of the escape sequence (starting with a
     96 /// backslash) to the end of the string literal.
     97 inline unsigned getEscapeSequenceLength(StringRef Text) {
     98   assert(Text[0] == '\\');
     99   if (Text.size() < 2)
    100     return 1;
    101 
    102   switch (Text[1]) {
    103   case 'u':
    104     return 6;
    105   case 'U':
    106     return 10;
    107   case 'x': {
    108     unsigned I = 2; // Point after '\x'.
    109     while (I < Text.size() && isHexDigit(Text[I]))
    110       ++I;
    111     return I;
    112   }
    113   default:
    114     if (isOctDigit(Text[1])) {
    115       unsigned I = 1;
    116       while (I < Text.size() && I < 4 && isOctDigit(Text[I]))
    117         ++I;
    118       return I;
    119     }
    120     return 1 + llvm::getNumBytesForUTF8(Text[1]);
    121   }
    122 }
    123 
    124 } // namespace encoding
    125 } // namespace format
    126 } // namespace clang
    127 
    128 #endif
    129