clang  10.0.0svn
CharInfo.h
Go to the documentation of this file.
1 //===--- clang/Basic/CharInfo.h - Classifying ASCII Characters --*- 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 #ifndef LLVM_CLANG_BASIC_CHARINFO_H
10 #define LLVM_CLANG_BASIC_CHARINFO_H
11 
12 #include "clang/Basic/LLVM.h"
13 #include "llvm/ADT/StringRef.h"
14 #include "llvm/Support/Compiler.h"
15 #include "llvm/Support/DataTypes.h"
16 
17 namespace clang {
18 namespace charinfo {
19  extern const uint16_t InfoTable[256];
20 
21  enum {
22  CHAR_HORZ_WS = 0x0001, // '\t', '\f', '\v'. Note, no '\0'
23  CHAR_VERT_WS = 0x0002, // '\r', '\n'
24  CHAR_SPACE = 0x0004, // ' '
25  CHAR_DIGIT = 0x0008, // 0-9
26  CHAR_XLETTER = 0x0010, // a-f,A-F
27  CHAR_UPPER = 0x0020, // A-Z
28  CHAR_LOWER = 0x0040, // a-z
29  CHAR_UNDER = 0x0080, // _
30  CHAR_PERIOD = 0x0100, // .
31  CHAR_RAWDEL = 0x0200, // {}[]#<>%:;?*+-/^&|~!=,"'
32  CHAR_PUNCT = 0x0400 // `$@()
33  };
34 
35  enum {
38  };
39 } // end namespace charinfo
40 
41 /// Returns true if this is an ASCII character.
42 LLVM_READNONE inline bool isASCII(char c) {
43  return static_cast<unsigned char>(c) <= 127;
44 }
45 
46 /// Returns true if this is a valid first character of a C identifier,
47 /// which is [a-zA-Z_].
48 LLVM_READONLY inline bool isIdentifierHead(unsigned char c,
49  bool AllowDollar = false) {
50  using namespace charinfo;
52  return true;
53  return AllowDollar && c == '$';
54 }
55 
56 /// Returns true if this is a body character of a C identifier,
57 /// which is [a-zA-Z0-9_].
58 LLVM_READONLY inline bool isIdentifierBody(unsigned char c,
59  bool AllowDollar = false) {
60  using namespace charinfo;
62  return true;
63  return AllowDollar && c == '$';
64 }
65 
66 /// Returns true if this character is horizontal ASCII whitespace:
67 /// ' ', '\\t', '\\f', '\\v'.
68 ///
69 /// Note that this returns false for '\\0'.
70 LLVM_READONLY inline bool isHorizontalWhitespace(unsigned char c) {
71  using namespace charinfo;
72  return (InfoTable[c] & (CHAR_HORZ_WS|CHAR_SPACE)) != 0;
73 }
74 
75 /// Returns true if this character is vertical ASCII whitespace: '\\n', '\\r'.
76 ///
77 /// Note that this returns false for '\\0'.
78 LLVM_READONLY inline bool isVerticalWhitespace(unsigned char c) {
79  using namespace charinfo;
80  return (InfoTable[c] & CHAR_VERT_WS) != 0;
81 }
82 
83 /// Return true if this character is horizontal or vertical ASCII whitespace:
84 /// ' ', '\\t', '\\f', '\\v', '\\n', '\\r'.
85 ///
86 /// Note that this returns false for '\\0'.
87 LLVM_READONLY inline bool isWhitespace(unsigned char c) {
88  using namespace charinfo;
89  return (InfoTable[c] & (CHAR_HORZ_WS|CHAR_VERT_WS|CHAR_SPACE)) != 0;
90 }
91 
92 /// Return true if this character is an ASCII digit: [0-9]
93 LLVM_READONLY inline bool isDigit(unsigned char c) {
94  using namespace charinfo;
95  return (InfoTable[c] & CHAR_DIGIT) != 0;
96 }
97 
98 /// Return true if this character is a lowercase ASCII letter: [a-z]
99 LLVM_READONLY inline bool isLowercase(unsigned char c) {
100  using namespace charinfo;
101  return (InfoTable[c] & CHAR_LOWER) != 0;
102 }
103 
104 /// Return true if this character is an uppercase ASCII letter: [A-Z]
105 LLVM_READONLY inline bool isUppercase(unsigned char c) {
106  using namespace charinfo;
107  return (InfoTable[c] & CHAR_UPPER) != 0;
108 }
109 
110 /// Return true if this character is an ASCII letter: [a-zA-Z]
111 LLVM_READONLY inline bool isLetter(unsigned char c) {
112  using namespace charinfo;
113  return (InfoTable[c] & (CHAR_UPPER|CHAR_LOWER)) != 0;
114 }
115 
116 /// Return true if this character is an ASCII letter or digit: [a-zA-Z0-9]
117 LLVM_READONLY inline bool isAlphanumeric(unsigned char c) {
118  using namespace charinfo;
119  return (InfoTable[c] & (CHAR_DIGIT|CHAR_UPPER|CHAR_LOWER)) != 0;
120 }
121 
122 /// Return true if this character is an ASCII hex digit: [0-9a-fA-F]
123 LLVM_READONLY inline bool isHexDigit(unsigned char c) {
124  using namespace charinfo;
125  return (InfoTable[c] & (CHAR_DIGIT|CHAR_XLETTER)) != 0;
126 }
127 
128 /// Return true if this character is an ASCII punctuation character.
129 ///
130 /// Note that '_' is both a punctuation character and an identifier character!
131 LLVM_READONLY inline bool isPunctuation(unsigned char c) {
132  using namespace charinfo;
134 }
135 
136 /// Return true if this character is an ASCII printable character; that is, a
137 /// character that should take exactly one column to print in a fixed-width
138 /// terminal.
139 LLVM_READONLY inline bool isPrintable(unsigned char c) {
140  using namespace charinfo;
143 }
144 
145 /// Return true if this is the body character of a C preprocessing number,
146 /// which is [a-zA-Z0-9_.].
147 LLVM_READONLY inline bool isPreprocessingNumberBody(unsigned char c) {
148  using namespace charinfo;
149  return (InfoTable[c] &
151 }
152 
153 /// Return true if this is the body character of a C++ raw string delimiter.
154 LLVM_READONLY inline bool isRawStringDelimBody(unsigned char c) {
155  using namespace charinfo;
158 }
159 
160 
161 /// Converts the given ASCII character to its lowercase equivalent.
162 ///
163 /// If the character is not an uppercase character, it is returned as is.
164 LLVM_READONLY inline char toLowercase(char c) {
165  if (isUppercase(c))
166  return c + 'a' - 'A';
167  return c;
168 }
169 
170 /// Converts the given ASCII character to its uppercase equivalent.
171 ///
172 /// If the character is not a lowercase character, it is returned as is.
173 LLVM_READONLY inline char toUppercase(char c) {
174  if (isLowercase(c))
175  return c + 'A' - 'a';
176  return c;
177 }
178 
179 
180 /// Return true if this is a valid ASCII identifier.
181 ///
182 /// Note that this is a very simple check; it does not accept UCNs as valid
183 /// identifier characters.
184 LLVM_READONLY inline bool isValidIdentifier(StringRef S,
185  bool AllowDollar = false) {
186  if (S.empty() || !isIdentifierHead(S[0], AllowDollar))
187  return false;
188 
189  for (StringRef::iterator I = S.begin(), E = S.end(); I != E; ++I)
190  if (!isIdentifierBody(*I, AllowDollar))
191  return false;
192 
193  return true;
194 }
195 
196 } // end namespace clang
197 
198 #endif
LLVM_READNONE bool isASCII(char c)
Returns true if this is an ASCII character.
Definition: CharInfo.h:42
LLVM_READONLY bool isHorizontalWhitespace(unsigned char c)
Returns true if this character is horizontal ASCII whitespace: &#39; &#39;, &#39;\t&#39;, &#39;\f&#39;, &#39;\v&#39;.
Definition: CharInfo.h:70
LLVM_READONLY bool isLetter(unsigned char c)
Return true if this character is an ASCII letter: [a-zA-Z].
Definition: CharInfo.h:111
LLVM_READONLY bool isWhitespace(unsigned char c)
Return true if this character is horizontal or vertical ASCII whitespace: &#39; &#39;, &#39;\t&#39;, &#39;\f&#39;, &#39;\v&#39;, &#39;\n&#39;, &#39;\r&#39;.
Definition: CharInfo.h:87
Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified...
LLVM_READONLY bool isUppercase(unsigned char c)
Return true if this character is an uppercase ASCII letter: [A-Z].
Definition: CharInfo.h:105
LLVM_READONLY bool isRawStringDelimBody(unsigned char c)
Return true if this is the body character of a C++ raw string delimiter.
Definition: CharInfo.h:154
LLVM_READONLY bool isIdentifierHead(unsigned char c, bool AllowDollar=false)
Returns true if this is a valid first character of a C identifier, which is [a-zA-Z_].
Definition: CharInfo.h:48
LLVM_READONLY bool isAlphanumeric(unsigned char c)
Return true if this character is an ASCII letter or digit: [a-zA-Z0-9].
Definition: CharInfo.h:117
LLVM_READONLY char toLowercase(char c)
Converts the given ASCII character to its lowercase equivalent.
Definition: CharInfo.h:164
LLVM_READONLY bool isValidIdentifier(StringRef S, bool AllowDollar=false)
Return true if this is a valid ASCII identifier.
Definition: CharInfo.h:184
LLVM_READONLY bool isPrintable(unsigned char c)
Return true if this character is an ASCII printable character; that is, a character that should take ...
Definition: CharInfo.h:139
LLVM_READONLY bool isLowercase(unsigned char c)
Return true if this character is a lowercase ASCII letter: [a-z].
Definition: CharInfo.h:99
Dataflow Directional Tag Classes.
LLVM_READONLY bool isVerticalWhitespace(unsigned char c)
Returns true if this character is vertical ASCII whitespace: &#39;\n&#39;, &#39;\r&#39;.
Definition: CharInfo.h:78
LLVM_READONLY bool isIdentifierBody(unsigned char c, bool AllowDollar=false)
Returns true if this is a body character of a C identifier, which is [a-zA-Z0-9_].
Definition: CharInfo.h:58
LLVM_READONLY bool isHexDigit(unsigned char c)
Return true if this character is an ASCII hex digit: [0-9a-fA-F].
Definition: CharInfo.h:123
LLVM_READONLY bool isDigit(unsigned char c)
Return true if this character is an ASCII digit: [0-9].
Definition: CharInfo.h:93
LLVM_READONLY bool isPunctuation(unsigned char c)
Return true if this character is an ASCII punctuation character.
Definition: CharInfo.h:131
const uint16_t InfoTable[256]
Definition: CharInfo.cpp:15
LLVM_READONLY char toUppercase(char c)
Converts the given ASCII character to its uppercase equivalent.
Definition: CharInfo.h:173
LLVM_READONLY bool isPreprocessingNumberBody(unsigned char c)
Return true if this is the body character of a C preprocessing number, which is [a-zA-Z0-9_.
Definition: CharInfo.h:147