|
150
|
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
|
