mfbt/TextUtils.h

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
   3 /* This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 /* Character/text operations. */
   8
   9 #ifndef mozilla_TextUtils_h
  10 #define mozilla_TextUtils_h
  11
  12 #include "mozilla/Assertions.h"
  13 #include "mozilla/TypeTraits.h"
  14
  15 namespace mozilla {
  16
  17 namespace detail {
  18
  19 template <typename Char>
  20 class MakeUnsignedChar : public MakeUnsigned<Char> {};
  21
  22 template <>
  23 class MakeUnsignedChar<char16_t> {
  24  public:
  25   using Type = char16_t;
  26 };
  27
  28 template <>
  29 class MakeUnsignedChar<char32_t> {
  30  public:
  31   using Type = char32_t;
  32 };
  33
  34 }  // namespace detail
  35
  36 /** Returns true iff |aChar| is ASCII, i.e. in the range [0, 0x80). */
  37 template <typename Char>
  38 constexpr bool IsAscii(Char aChar) {
  39   using UnsignedChar = typename detail::MakeUnsignedChar<Char>::Type;
  40   auto uc = static_cast<UnsignedChar>(aChar);
  41   return uc < 0x80;
  42 }
  43
  44 template <typename Char>
  45 constexpr bool IsNonAsciiLatin1(Char aChar) {
  46   using UnsignedChar = typename detail::MakeUnsignedChar<Char>::Type;
  47   auto uc = static_cast<UnsignedChar>(aChar);
  48   return uc >= 0x80 && uc <= 0xFF;
  49 }
  50
  51 /**
  52  * Returns true iff |aChar| matches Ascii Whitespace.
  53  *
  54  * This function is intended to match the Infra standard
  55  * (https://infra.spec.whatwg.org/#ascii-whitespace)
  56  */
  57 template <typename Char>
  58 constexpr bool IsAsciiWhitespace(Char aChar) {
  59   using UnsignedChar = typename detail::MakeUnsignedChar<Char>::Type;
  60   auto uc = static_cast<UnsignedChar>(aChar);
  61   return uc == 0x9 || uc == 0xA || uc == 0xC || uc == 0xD || uc == 0x20;
  62 }
  63
  64 /**
  65  * Returns true iff |aChar| matches [a-z].
  66  *
  67  * This function is basically what you thought islower was, except its behavior
  68  * doesn't depend on the user's current locale.
  69  */
  70 template <typename Char>
  71 constexpr bool IsAsciiLowercaseAlpha(Char aChar) {
  72   using UnsignedChar = typename detail::MakeUnsignedChar<Char>::Type;
  73   auto uc = static_cast<UnsignedChar>(aChar);
  74   return 'a' <= uc && uc <= 'z';
  75 }
  76
  77 /**
  78  * Returns true iff |aChar| matches [A-Z].
  79  *
  80  * This function is basically what you thought isupper was, except its behavior
  81  * doesn't depend on the user's current locale.
  82  */
  83 template <typename Char>
  84 constexpr bool IsAsciiUppercaseAlpha(Char aChar) {
  85   using UnsignedChar = typename detail::MakeUnsignedChar<Char>::Type;
  86   auto uc = static_cast<UnsignedChar>(aChar);
  87   return 'A' <= uc && uc <= 'Z';
  88 }
  89
  90 /**
  91  * Returns true iff |aChar| matches [a-zA-Z].
  92  *
  93  * This function is basically what you thought isalpha was, except its behavior
  94  * doesn't depend on the user's current locale.
  95  */
  96 template <typename Char>
  97 constexpr bool IsAsciiAlpha(Char aChar) {
  98   return IsAsciiLowercaseAlpha(aChar) || IsAsciiUppercaseAlpha(aChar);
  99 }
 100
 101 /**
 102  * Returns true iff |aChar| matches [0-9].
 103  *
 104  * This function is basically what you thought isdigit was, except its behavior
 105  * doesn't depend on the user's current locale.
 106  */
 107 template <typename Char>
 108 constexpr bool IsAsciiDigit(Char aChar) {
 109   using UnsignedChar = typename detail::MakeUnsignedChar<Char>::Type;
 110   auto uc = static_cast<UnsignedChar>(aChar);
 111   return '0' <= uc && uc <= '9';
 112 }
 113
 114 /**
 115  * Returns true iff |aChar| matches [0-9a-fA-F].
 116  *
 117  * This function is basically isxdigit, but guaranteed to be only for ASCII.
 118  */
 119 template <typename Char>
 120 constexpr bool IsAsciiHexDigit(Char aChar) {
 121   using UnsignedChar = typename detail::MakeUnsignedChar<Char>::Type;
 122   auto uc = static_cast<UnsignedChar>(aChar);
 123   return ('0' <= uc && uc <= '9') || ('a' <= uc && uc <= 'f') ||
 124          ('A' <= uc && uc <= 'F');
 125 }
 126
 127 /**
 128  * Returns true iff |aChar| matches [a-zA-Z0-9].
 129  *
 130  * This function is basically what you thought isalnum was, except its behavior
 131  * doesn't depend on the user's current locale.
 132  */
 133 template <typename Char>
 134 constexpr bool IsAsciiAlphanumeric(Char aChar) {
 135   return IsAsciiDigit(aChar) || IsAsciiAlpha(aChar);
 136 }
 137
 138 /**
 139  * Converts an ASCII alphanumeric digit [0-9a-zA-Z] to number as if in base-36.
 140  * (This function therefore works for decimal, hexadecimal, etc.).
 141  */
 142 template <typename Char>
 143 uint8_t AsciiAlphanumericToNumber(Char aChar) {
 144   using UnsignedChar = typename detail::MakeUnsignedChar<Char>::Type;
 145   auto uc = static_cast<UnsignedChar>(aChar);
 146
 147   if ('0' <= uc && uc <= '9') {
 148     return uc - '0';
 149   }
 150
 151   if ('A' <= uc && uc <= 'Z') {
 152     return uc - 'A' + 10;
 153   }
 154
 155   // Ideally this function would be constexpr, but unfortunately gcc at least as
 156   // of 6.4 forbids non-constexpr function calls in unevaluated constexpr
 157   // function calls.  See bug 1453456.  So for now, just assert and leave the
 158   // entire function non-constexpr.
 159   MOZ_ASSERT('a' <= uc && uc <= 'z',
 160              "non-ASCII alphanumeric character can't be converted to number");
 161   return uc - 'a' + 10;
 162 }
 163
 164 }  // namespace mozilla
 165
 166 #endif /* mozilla_TextUtils_h */