Coverage Report

Created: 2020-09-15 12:33

/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
36.3k
inline Encoding detectEncoding(StringRef Text) {
35
36.3k
  const llvm::UTF8 *Ptr = reinterpret_cast<const llvm::UTF8 *>(Text.begin());
36
36.3k
  const llvm::UTF8 *BufEnd = reinterpret_cast<const llvm::UTF8 *>(Text.end());
37
36.3k
  if (llvm::isLegalUTF8String(&Ptr, BufEnd))
38
36.3k
    return Encoding_UTF8;
39
6
  return Encoding_Unknown;
40
6
}
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
704k
inline unsigned columnWidth(StringRef Text, Encoding Encoding) {
46
704k
  if (Encoding == Encoding_UTF8) {
47
704k
    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
704k
    if (ContentWidth >= 0)
53
704k
      return ContentWidth;
54
400
  }
55
400
  return Text.size();
56
400
}
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
704k
                                    unsigned TabWidth, Encoding Encoding) {
63
704k
  unsigned TotalWidth = 0;
64
704k
  StringRef Tail = Text;
65
704k
  for (;;) {
66
704k
    StringRef::size_type TabPos = Tail.find('\t');
67
704k
    if (TabPos == StringRef::npos)
68
704k
      return TotalWidth + columnWidth(Tail, Encoding);
69
510
    TotalWidth += columnWidth(Tail.substr(0, TabPos), Encoding);
70
510
    if (TabWidth)
71
450
      TotalWidth += TabWidth - (TotalWidth + StartColumn) % TabWidth;
72
510
    Tail = Tail.substr(TabPos + 1);
73
510
  }
74
704k
}
75
76
/// Gets the number of bytes in a sequence representing a single
77
/// codepoint and starting with FirstChar in the specified Encoding.
78
51.6k
inline unsigned getCodePointNumBytes(char FirstChar, Encoding Encoding) {
79
51.6k
  switch (Encoding) {
80
51.5k
  case Encoding_UTF8:
81
51.5k
    return llvm::getNumBytesForUTF8(FirstChar);
82
66
  default:
83
66
    return 1;
84
51.6k
  }
85
51.6k
}
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
4
         ('A' <= c && c <= 'F');
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
35
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