Clang Project

clang_source_code/include/clang/Basic/CharInfo.h
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
17namespace clang {
18namespace 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 {
36    CHAR_XUPPER = CHAR_XLETTER | CHAR_UPPER,
37    CHAR_XLOWER = CHAR_XLETTER | CHAR_LOWER
38  };
39} // end namespace charinfo
40
41/// Returns true if this is an ASCII character.
42LLVM_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_].
48LLVM_READONLY inline bool isIdentifierHead(unsigned char c,
49                                           bool AllowDollar = false) {
50  using namespace charinfo;
51  if (InfoTable[c] & (CHAR_UPPER|CHAR_LOWER|CHAR_UNDER))
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_].
58LLVM_READONLY inline bool isIdentifierBody(unsigned char c,
59                                           bool AllowDollar = false) {
60  using namespace charinfo;
61  if (InfoTable[c] & (CHAR_UPPER|CHAR_LOWER|CHAR_DIGIT|CHAR_UNDER))
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'.
70LLVM_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'.
78LLVM_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'.
87LLVM_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]
93LLVM_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]
99LLVM_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]
105LLVM_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]
111LLVM_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]
117LLVM_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]
123LLVM_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!
131LLVM_READONLY inline bool isPunctuation(unsigned char c) {
132  using namespace charinfo;
133  return (InfoTable[c] & (CHAR_UNDER|CHAR_PERIOD|CHAR_RAWDEL|CHAR_PUNCT)) != 0;
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.
139LLVM_READONLY inline bool isPrintable(unsigned char c) {
140  using namespace charinfo;
141  return (InfoTable[c] & (CHAR_UPPER|CHAR_LOWER|CHAR_PERIOD|CHAR_PUNCT|
142                          CHAR_DIGIT|CHAR_UNDER|CHAR_RAWDEL|CHAR_SPACE)) != 0;
143}
144
145/// Return true if this is the body character of a C preprocessing number,
146/// which is [a-zA-Z0-9_.].
147LLVM_READONLY inline bool isPreprocessingNumberBody(unsigned char c) {
148  using namespace charinfo;
149  return (InfoTable[c] &
150          (CHAR_UPPER|CHAR_LOWER|CHAR_DIGIT|CHAR_UNDER|CHAR_PERIOD)) != 0;
151}
152
153/// Return true if this is the body character of a C++ raw string delimiter.
154LLVM_READONLY inline bool isRawStringDelimBody(unsigned char c) {
155  using namespace charinfo;
156  return (InfoTable[c] & (CHAR_UPPER|CHAR_LOWER|CHAR_PERIOD|
157                          CHAR_DIGIT|CHAR_UNDER|CHAR_RAWDEL)) != 0;
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.
164LLVM_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.
173LLVM_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.
184LLVM_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
199
CodeThinker, Enjoy your reading code