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