contrib/llvm/tools/clang/include/clang/Basic/CharInfo.h

   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 CLANG_BASIC_CHARINFO_H
  11 #define 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
  18 namespace clang {
  19 namespace 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.
  43 LLVM_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_].
  49 LLVM_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_].
  59 LLVM_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'.
  71 LLVM_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'.
  79 LLVM_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'.
  88 LLVM_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]
  94 LLVM_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]
 100 LLVM_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]
 106 LLVM_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]
 112 LLVM_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]
 118 LLVM_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]
 124 LLVM_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!
 132 LLVM_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.
 140 LLVM_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_.].
 148 LLVM_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.
 155 LLVM_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.
 165 LLVM_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.
 174 LLVM_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.
 185 LLVM_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