Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

Rev

Blame | Last modification | View Log | Download | RSS feed

  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 {
  36.     CHAR_XUPPER = CHAR_XLETTER | CHAR_UPPER,
  37.     CHAR_XLOWER = CHAR_XLETTER | CHAR_LOWER
  38.   };
  39. } // end namespace charinfo
  40.  
  41. /// Returns true if a byte is an ASCII character.
  42. LLVM_READNONE inline bool isASCII(char c) {
  43.   return static_cast<unsigned char>(c) <= 127;
  44. }
  45.  
  46. LLVM_READNONE inline bool isASCII(unsigned char c) { return c <= 127; }
  47.  
  48. /// Returns true if a codepoint is an ASCII character.
  49. LLVM_READNONE inline bool isASCII(uint32_t c) { return c <= 127; }
  50. LLVM_READNONE inline bool isASCII(int64_t c) { return 0 <= c && c <= 127; }
  51.  
  52. /// Returns true if this is a valid first character of a C identifier,
  53. /// which is [a-zA-Z_].
  54. LLVM_READONLY inline bool isAsciiIdentifierStart(unsigned char c,
  55.                                                  bool AllowDollar = false) {
  56.   using namespace charinfo;
  57.   if (InfoTable[c] & (CHAR_UPPER|CHAR_LOWER|CHAR_UNDER))
  58.     return true;
  59.   return AllowDollar && c == '$';
  60. }
  61.  
  62. /// Returns true if this is a body character of a C identifier,
  63. /// which is [a-zA-Z0-9_].
  64. LLVM_READONLY inline bool isAsciiIdentifierContinue(unsigned char c,
  65.                                                     bool AllowDollar = false) {
  66.   using namespace charinfo;
  67.   if (InfoTable[c] & (CHAR_UPPER|CHAR_LOWER|CHAR_DIGIT|CHAR_UNDER))
  68.     return true;
  69.   return AllowDollar && c == '$';
  70. }
  71.  
  72. /// Returns true if this character is horizontal ASCII whitespace:
  73. /// ' ', '\\t', '\\f', '\\v'.
  74. ///
  75. /// Note that this returns false for '\\0'.
  76. LLVM_READONLY inline bool isHorizontalWhitespace(unsigned char c) {
  77.   using namespace charinfo;
  78.   return (InfoTable[c] & (CHAR_HORZ_WS|CHAR_SPACE)) != 0;
  79. }
  80.  
  81. /// Returns true if this character is vertical ASCII whitespace: '\\n', '\\r'.
  82. ///
  83. /// Note that this returns false for '\\0'.
  84. LLVM_READONLY inline bool isVerticalWhitespace(unsigned char c) {
  85.   using namespace charinfo;
  86.   return (InfoTable[c] & CHAR_VERT_WS) != 0;
  87. }
  88.  
  89. /// Return true if this character is horizontal or vertical ASCII whitespace:
  90. /// ' ', '\\t', '\\f', '\\v', '\\n', '\\r'.
  91. ///
  92. /// Note that this returns false for '\\0'.
  93. LLVM_READONLY inline bool isWhitespace(unsigned char c) {
  94.   using namespace charinfo;
  95.   return (InfoTable[c] & (CHAR_HORZ_WS|CHAR_VERT_WS|CHAR_SPACE)) != 0;
  96. }
  97.  
  98. /// Return true if this character is an ASCII digit: [0-9]
  99. LLVM_READONLY inline bool isDigit(unsigned char c) {
  100.   using namespace charinfo;
  101.   return (InfoTable[c] & CHAR_DIGIT) != 0;
  102. }
  103.  
  104. /// Return true if this character is a lowercase ASCII letter: [a-z]
  105. LLVM_READONLY inline bool isLowercase(unsigned char c) {
  106.   using namespace charinfo;
  107.   return (InfoTable[c] & CHAR_LOWER) != 0;
  108. }
  109.  
  110. /// Return true if this character is an uppercase ASCII letter: [A-Z]
  111. LLVM_READONLY inline bool isUppercase(unsigned char c) {
  112.   using namespace charinfo;
  113.   return (InfoTable[c] & CHAR_UPPER) != 0;
  114. }
  115.  
  116. /// Return true if this character is an ASCII letter: [a-zA-Z]
  117. LLVM_READONLY inline bool isLetter(unsigned char c) {
  118.   using namespace charinfo;
  119.   return (InfoTable[c] & (CHAR_UPPER|CHAR_LOWER)) != 0;
  120. }
  121.  
  122. /// Return true if this character is an ASCII letter or digit: [a-zA-Z0-9]
  123. LLVM_READONLY inline bool isAlphanumeric(unsigned char c) {
  124.   using namespace charinfo;
  125.   return (InfoTable[c] & (CHAR_DIGIT|CHAR_UPPER|CHAR_LOWER)) != 0;
  126. }
  127.  
  128. /// Return true if this character is an ASCII hex digit: [0-9a-fA-F]
  129. LLVM_READONLY inline bool isHexDigit(unsigned char c) {
  130.   using namespace charinfo;
  131.   return (InfoTable[c] & (CHAR_DIGIT|CHAR_XLETTER)) != 0;
  132. }
  133.  
  134. /// Return true if this character is an ASCII punctuation character.
  135. ///
  136. /// Note that '_' is both a punctuation character and an identifier character!
  137. LLVM_READONLY inline bool isPunctuation(unsigned char c) {
  138.   using namespace charinfo;
  139.   return (InfoTable[c] & (CHAR_UNDER|CHAR_PERIOD|CHAR_RAWDEL|CHAR_PUNCT)) != 0;
  140. }
  141.  
  142. /// Return true if this character is an ASCII printable character; that is, a
  143. /// character that should take exactly one column to print in a fixed-width
  144. /// terminal.
  145. LLVM_READONLY inline bool isPrintable(unsigned char c) {
  146.   using namespace charinfo;
  147.   return (InfoTable[c] & (CHAR_UPPER|CHAR_LOWER|CHAR_PERIOD|CHAR_PUNCT|
  148.                           CHAR_DIGIT|CHAR_UNDER|CHAR_RAWDEL|CHAR_SPACE)) != 0;
  149. }
  150.  
  151. /// Return true if this is the body character of a C preprocessing number,
  152. /// which is [a-zA-Z0-9_.].
  153. LLVM_READONLY inline bool isPreprocessingNumberBody(unsigned char c) {
  154.   using namespace charinfo;
  155.   return (InfoTable[c] &
  156.           (CHAR_UPPER|CHAR_LOWER|CHAR_DIGIT|CHAR_UNDER|CHAR_PERIOD)) != 0;
  157. }
  158.  
  159. /// Return true if this is the body character of a C++ raw string delimiter.
  160. LLVM_READONLY inline bool isRawStringDelimBody(unsigned char c) {
  161.   using namespace charinfo;
  162.   return (InfoTable[c] & (CHAR_UPPER|CHAR_LOWER|CHAR_PERIOD|
  163.                           CHAR_DIGIT|CHAR_UNDER|CHAR_RAWDEL)) != 0;
  164. }
  165.  
  166. enum class EscapeChar {
  167.   Single = 1,
  168.   Double = 2,
  169.   SingleAndDouble = static_cast<int>(Single) | static_cast<int>(Double),
  170. };
  171.  
  172. /// Return C-style escaped string for special characters, or an empty string if
  173. /// there is no such mapping.
  174. template <EscapeChar Opt, class CharT>
  175. LLVM_READONLY inline auto escapeCStyle(CharT Ch) -> StringRef {
  176.   switch (Ch) {
  177.   case '\\':
  178.     return "\\\\";
  179.   case '\'':
  180.     if ((static_cast<int>(Opt) & static_cast<int>(EscapeChar::Single)) == 0)
  181.       break;
  182.     return "\\'";
  183.   case '"':
  184.     if ((static_cast<int>(Opt) & static_cast<int>(EscapeChar::Double)) == 0)
  185.       break;
  186.     return "\\\"";
  187.   case '\a':
  188.     return "\\a";
  189.   case '\b':
  190.     return "\\b";
  191.   case '\f':
  192.     return "\\f";
  193.   case '\n':
  194.     return "\\n";
  195.   case '\r':
  196.     return "\\r";
  197.   case '\t':
  198.     return "\\t";
  199.   case '\v':
  200.     return "\\v";
  201.   }
  202.   return {};
  203. }
  204.  
  205. /// Converts the given ASCII character to its lowercase equivalent.
  206. ///
  207. /// If the character is not an uppercase character, it is returned as is.
  208. LLVM_READONLY inline char toLowercase(char c) {
  209.   if (isUppercase(c))
  210.     return c + 'a' - 'A';
  211.   return c;
  212. }
  213.  
  214. /// Converts the given ASCII character to its uppercase equivalent.
  215. ///
  216. /// If the character is not a lowercase character, it is returned as is.
  217. LLVM_READONLY inline char toUppercase(char c) {
  218.   if (isLowercase(c))
  219.     return c + 'A' - 'a';
  220.   return c;
  221. }
  222.  
  223.  
  224. /// Return true if this is a valid ASCII identifier.
  225. ///
  226. /// Note that this is a very simple check; it does not accept UCNs as valid
  227. /// identifier characters.
  228. LLVM_READONLY inline bool isValidAsciiIdentifier(StringRef S,
  229.                                                  bool AllowDollar = false) {
  230.   if (S.empty() || !isAsciiIdentifierStart(S[0], AllowDollar))
  231.     return false;
  232.  
  233.   for (StringRef::iterator I = S.begin(), E = S.end(); I != E; ++I)
  234.     if (!isAsciiIdentifierContinue(*I, AllowDollar))
  235.       return false;
  236.  
  237.   return true;
  238. }
  239.  
  240. } // end namespace clang
  241.  
  242. #endif
  243.