js/public/RegExpFlags.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 /* Regular expression flags. */
   8
   9 #ifndef js_RegExpFlags_h
  10 #define js_RegExpFlags_h
  11
  12 #include "mozilla/Assertions.h"  // MOZ_ASSERT
  13 #include "mozilla/Attributes.h"  // MOZ_IMPLICIT
  14
  15 #include <stdint.h>  // uint8_t
  16
  17 namespace JS {
  18
  19 /**
  20  * Regular expression flag values, suitable for initializing a collection of
  21  * regular expression flags as defined below in |RegExpFlags|.  Flags are listed
  22  * in alphabetical order by syntax -- /d, /g, /i, /m, /s, /u, /v, /y.
  23  */
  24 class RegExpFlag {
  25   // WARNING TO SPIDERMONKEY HACKERS (embedders must assume these values can
  26   // change):
  27   //
  28   // Flag-bit values appear in XDR and structured clone data formats, so none of
  29   // these values can be changed (including to assign values in numerically
  30   // ascending order) unless you also add a translation layer.
  31
  32  public:
  33   /**
  34    * Add .indices property to the match result, i.e. /d
  35    */
  36   static constexpr uint8_t HasIndices = 0b0100'0000;
  37
  38   /**
  39    * Act globally and find *all* matches (rather than stopping after just the
  40    * first one), i.e. /g.
  41    */
  42   static constexpr uint8_t Global = 0b0000'0010;
  43
  44   /**
  45    * Interpret regular expression source text case-insensitively by folding
  46    * uppercase letters to lowercase, i.e. /i.
  47    */
  48   static constexpr uint8_t IgnoreCase = 0b0000'0001;
  49
  50   /** Treat ^ and $ as begin and end of line, i.e. /m. */
  51   static constexpr uint8_t Multiline = 0b0000'0100;
  52
  53   /* Allow . to match newline characters, i.e. /s. */
  54   static constexpr uint8_t DotAll = 0b0010'0000;
  55
  56   /** Use Unicode semantics, i.e. /u. */
  57   static constexpr uint8_t Unicode = 0b0001'0000;
  58
  59   /** Use Unicode Sets semantics, i.e. /v. */
  60   static constexpr uint8_t UnicodeSets = 0b1000'0000;
  61
  62   /** Only match starting from <regular expression>.lastIndex, i.e. /y. */
  63   static constexpr uint8_t Sticky = 0b0000'1000;
  64
  65   /** No regular expression flags. */
  66   static constexpr uint8_t NoFlags = 0b0000'0000;
  67
  68   /** All regular expression flags. */
  69   static constexpr uint8_t AllFlags = 0b1111'1111;
  70 };
  71
  72 /**
  73  * A collection of regular expression flags.  Individual flag values may be
  74  * combined into a collection using bitwise operators.
  75  */
  76 class RegExpFlags {
  77  public:
  78   using Flag = uint8_t;
  79
  80  private:
  81   Flag flags_;
  82
  83  public:
  84   RegExpFlags() = default;
  85
  86   MOZ_IMPLICIT RegExpFlags(Flag flags) : flags_(flags) {
  87     MOZ_ASSERT((flags & RegExpFlag::AllFlags) == flags,
  88                "flags must not contain unrecognized flags");
  89   }
  90
  91   RegExpFlags(const RegExpFlags&) = default;
  92   RegExpFlags& operator=(const RegExpFlags&) = default;
  93
  94   bool operator==(const RegExpFlags& other) const {
  95     return flags_ == other.flags_;
  96   }
  97
  98   bool operator!=(const RegExpFlags& other) const { return !(*this == other); }
  99
 100   RegExpFlags& operator&=(const RegExpFlags& rhs) {
 101     flags_ &= rhs.flags_;
 102     return *this;
 103   }
 104
 105   RegExpFlags& operator|=(const RegExpFlags& rhs) {
 106     flags_ |= rhs.flags_;
 107     return *this;
 108   }
 109
 110   RegExpFlags operator&(Flag flag) const { return RegExpFlags(flags_ & flag); }
 111
 112   RegExpFlags operator|(Flag flag) const { return RegExpFlags(flags_ | flag); }
 113
 114   RegExpFlags operator^(Flag flag) const { return RegExpFlags(flags_ ^ flag); }
 115
 116   RegExpFlags operator~() const {
 117     return RegExpFlags(~flags_ & RegExpFlag::AllFlags);
 118   }
 119
 120   bool hasIndices() const { return flags_ & RegExpFlag::HasIndices; }
 121   bool global() const { return flags_ & RegExpFlag::Global; }
 122   bool ignoreCase() const { return flags_ & RegExpFlag::IgnoreCase; }
 123   bool multiline() const { return flags_ & RegExpFlag::Multiline; }
 124   bool dotAll() const { return flags_ & RegExpFlag::DotAll; }
 125   bool unicode() const { return flags_ & RegExpFlag::Unicode; }
 126   bool unicodeSets() const { return flags_ & RegExpFlag::UnicodeSets; }
 127   bool sticky() const { return flags_ & RegExpFlag::Sticky; }
 128
 129   explicit operator bool() const { return flags_ != 0; }
 130
 131   Flag value() const { return flags_; }
 132 };
 133
 134 inline RegExpFlags& operator&=(RegExpFlags& flags, RegExpFlags::Flag flag) {
 135   flags = flags & flag;
 136   return flags;
 137 }
 138
 139 inline RegExpFlags& operator|=(RegExpFlags& flags, RegExpFlags::Flag flag) {
 140   flags = flags | flag;
 141   return flags;
 142 }
 143
 144 inline RegExpFlags& operator^=(RegExpFlags& flags, RegExpFlags::Flag flag) {
 145   flags = flags ^ flag;
 146   return flags;
 147 }
 148
 149 inline RegExpFlags operator&(const RegExpFlags& lhs, const RegExpFlags& rhs) {
 150   RegExpFlags result = lhs;
 151   result &= rhs;
 152   return lhs;
 153 }
 154
 155 inline RegExpFlags operator|(const RegExpFlags& lhs, const RegExpFlags& rhs) {
 156   RegExpFlags result = lhs;
 157   result |= rhs;
 158   return result;
 159 }
 160
 161 }  // namespace JS
 162
 163 #endif  // js_RegExpFlags_h