/Users/buildslave/jenkins/workspace/coverage/llvm-project/clang/lib/Format/Encoding.h
Line | Count | Source (jump to first uncovered line) |
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 | 65.1k | inline Encoding detectEncoding(StringRef Text) { |
35 | 65.1k | const llvm::UTF8 *Ptr = reinterpret_cast<const llvm::UTF8 *>(Text.begin()); |
36 | 65.1k | const llvm::UTF8 *BufEnd = reinterpret_cast<const llvm::UTF8 *>(Text.end()); |
37 | 65.1k | if (llvm::isLegalUTF8String(&Ptr, BufEnd)) |
38 | 65.1k | return Encoding_UTF8; |
39 | 6 | return Encoding_Unknown; |
40 | 65.1k | } |
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 | 1.24M | inline unsigned columnWidth(StringRef Text, Encoding Encoding) { |
46 | 1.24M | if (Encoding == Encoding_UTF8) { |
47 | 1.24M | 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 | 1.24M | if (ContentWidth >= 0) |
53 | 1.24M | return ContentWidth; |
54 | 1.24M | } |
55 | 526 | return Text.size(); |
56 | 1.24M | } |
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 | 1.23M | unsigned TabWidth, Encoding Encoding) { |
63 | 1.23M | unsigned TotalWidth = 0; |
64 | 1.23M | StringRef Tail = Text; |
65 | 1.23M | for (;;) { |
66 | 1.23M | StringRef::size_type TabPos = Tail.find('\t'); |
67 | 1.23M | if (TabPos == StringRef::npos) |
68 | 1.23M | return TotalWidth + columnWidth(Tail, Encoding); |
69 | 570 | TotalWidth += columnWidth(Tail.substr(0, TabPos), Encoding); |
70 | 570 | if (TabWidth) |
71 | 510 | TotalWidth += TabWidth - (TotalWidth + StartColumn) % TabWidth; |
72 | 570 | Tail = Tail.substr(TabPos + 1); |
73 | 570 | } |
74 | 1.23M | } |
75 | | |
76 | | /// Gets the number of bytes in a sequence representing a single |
77 | | /// codepoint and starting with FirstChar in the specified Encoding. |
78 | 91.3k | inline unsigned getCodePointNumBytes(char FirstChar, Encoding Encoding) { |
79 | 91.3k | switch (Encoding) { |
80 | 91.2k | case Encoding_UTF8: |
81 | 91.2k | return llvm::getNumBytesForUTF8(FirstChar); |
82 | 66 | default: |
83 | 66 | return 1; |
84 | 91.3k | } |
85 | 91.3k | } |
86 | | |
87 | 38 | inline bool isOctDigit(char c) { return '0' <= c && c <= '7'36 ; } |
88 | | |
89 | 76 | inline bool isHexDigit(char c) { |
90 | 76 | return ('0' <= c && c <= '9') || (4 'a' <= c4 && c <= 'f'4 ) || |
91 | 76 | (4 'A' <= c4 && c <= 'F'4 ); |
92 | 76 | } |
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 | 35 | inline unsigned getEscapeSequenceLength(StringRef Text) { |
98 | 35 | assert(Text[0] == '\\'); |
99 | 35 | if (Text.size() < 2) |
100 | 0 | return 1; |
101 | | |
102 | 35 | switch (Text[1]) { |
103 | 7 | case 'u': |
104 | 7 | return 6; |
105 | 2 | case 'U': |
106 | 2 | return 10; |
107 | 6 | case 'x': { |
108 | 6 | unsigned I = 2; // Point after '\x'. |
109 | 78 | while (I < Text.size() && isHexDigit(Text[I])76 ) |
110 | 72 | ++I; |
111 | 6 | return I; |
112 | 0 | } |
113 | 20 | default: |
114 | 20 | if (isOctDigit(Text[1])) { |
115 | 6 | unsigned I = 1; |
116 | 24 | while (I < Text.size() && I < 4 && isOctDigit(Text[I])18 ) |
117 | 18 | ++I; |
118 | 6 | return I; |
119 | 6 | } |
120 | 14 | return 1 + llvm::getNumBytesForUTF8(Text[1]); |
121 | 35 | } |
122 | 35 | } |
123 | | |
124 | | } // namespace encoding |
125 | | } // namespace format |
126 | | } // namespace clang |
127 | | |
128 | | #endif |