diff --git a/libstdc++-v3/include/bits/regex.h b/libstdc++-v3/include/bits/regex.h
index a23c2c9..99ac973 100644
--- a/libstdc++-v3/include/bits/regex.h
+++ b/libstdc++-v3/include/bits/regex.h
@@ -782,6 +782,46 @@ _GLIBCXX_BEGIN_NAMESPACE_CXX11
       _AutomatonPtr          _M_automaton;
     };
 
+  template<typename _Ch_type, typename _Rx_traits>
+    constexpr regex_constants::syntax_option_type
+    basic_regex<_Ch_type, _Rx_traits>::icase;
+
+  template<typename _Ch_type, typename _Rx_traits>
+    constexpr regex_constants::syntax_option_type
+    basic_regex<_Ch_type, _Rx_traits>::nosubs;
+
+  template<typename _Ch_type, typename _Rx_traits>
+    constexpr regex_constants::syntax_option_type
+    basic_regex<_Ch_type, _Rx_traits>::optimize;
+
+  template<typename _Ch_type, typename _Rx_traits>
+    constexpr regex_constants::syntax_option_type
+    basic_regex<_Ch_type, _Rx_traits>::collate;
+
+  template<typename _Ch_type, typename _Rx_traits>
+    constexpr regex_constants::syntax_option_type
+    basic_regex<_Ch_type, _Rx_traits>::ECMAScript;
+
+  template<typename _Ch_type, typename _Rx_traits>
+    constexpr regex_constants::syntax_option_type
+    basic_regex<_Ch_type, _Rx_traits>::basic;
+
+  template<typename _Ch_type, typename _Rx_traits>
+    constexpr regex_constants::syntax_option_type
+    basic_regex<_Ch_type, _Rx_traits>::extended;
+
+  template<typename _Ch_type, typename _Rx_traits>
+    constexpr regex_constants::syntax_option_type
+    basic_regex<_Ch_type, _Rx_traits>::awk;
+
+  template<typename _Ch_type, typename _Rx_traits>
+    constexpr regex_constants::syntax_option_type
+    basic_regex<_Ch_type, _Rx_traits>::grep;
+
+  template<typename _Ch_type, typename _Rx_traits>
+    constexpr regex_constants::syntax_option_type
+    basic_regex<_Ch_type, _Rx_traits>::egrep;
+
   /** @brief Standard regular expressions. */
   typedef basic_regex<char>    regex;
 
diff --git a/libstdc++-v3/include/bits/regex_constants.h b/libstdc++-v3/include/bits/regex_constants.h
index 1ef5a43..1514a50 100644
--- a/libstdc++-v3/include/bits/regex_constants.h
+++ b/libstdc++-v3/include/bits/regex_constants.h
@@ -51,19 +51,92 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
    * @name 5.1 Regular Expression Syntax Options
    */
   //@{
-  enum __syntax_option
+
+  class syntax_option_type
   {
-    _S_icase,
-    _S_nosubs,
-    _S_optimize,
-    _S_collate,
-    _S_ECMAScript,
-    _S_basic,
-    _S_extended,
-    _S_awk,
-    _S_grep,
-    _S_egrep,
-    _S_syntax_last
+  private:
+    enum __syntax_option
+    {
+      _S_op_icase,
+      _S_op_nosubs,
+      _S_op_optimize,
+      _S_op_collate,
+      _S_op_ECMAScript,
+      _S_op_basic,
+      _S_op_extended,
+      _S_op_awk,
+      _S_op_grep,
+      _S_op_egrep,
+      _S_op_syntax_last
+    };
+
+    constexpr
+    syntax_option_type(unsigned int __flag) : _M_flag(__flag) { }
+
+  public:
+    enum _Flag : unsigned int
+    {
+      _S_icase = 1 << _S_op_icase,
+      _S_nosubs = 1 << _S_op_nosubs,
+      _S_optimize = 1 << _S_op_optimize,
+      _S_collate = 1 << _S_op_collate,
+      _S_ECMAScript = 1 << _S_op_ECMAScript,
+      _S_basic = 1 << _S_op_basic,
+      _S_extended = 1 << _S_op_extended,
+      _S_awk = 1 << _S_op_awk,
+      _S_grep = 1 << _S_op_grep,
+      _S_egrep = 1 << _S_op_egrep,
+    };
+
+    constexpr
+    syntax_option_type(_Flag __flag = _S_ECMAScript) : _M_flag(__flag) { }
+
+    constexpr
+    syntax_option_type(const syntax_option_type&) = default;
+
+    constexpr syntax_option_type
+    operator&(syntax_option_type __rhs) const
+    { return _M_flag & __rhs._M_flag; }
+
+    constexpr syntax_option_type
+    operator|(syntax_option_type __rhs) const
+    { return _M_flag | __rhs._M_flag; }
+
+    constexpr syntax_option_type
+    operator^(syntax_option_type __rhs) const
+    { return _M_flag ^ __rhs._M_flag; }
+
+    constexpr syntax_option_type
+    operator~() const
+    { return ~_M_flag; }
+
+    syntax_option_type&
+    operator&=(syntax_option_type __rhs)
+    {
+      _M_flag &= __rhs._M_flag;
+      return *this;
+    }
+
+    syntax_option_type&
+    operator|=(syntax_option_type __rhs)
+    {
+      _M_flag |= __rhs._M_flag;
+      return *this;
+    }
+
+    syntax_option_type&
+    operator^=(syntax_option_type __rhs)
+    {
+      _M_flag ^= __rhs._M_flag;
+      return *this;
+    }
+
+    constexpr
+    operator bool() const
+    { return _M_flag; }
+
+  private:
+    unsigned int _M_flag;
   };
 
   /**
@@ -77,125 +150,86 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
    * elements @c ECMAScript, @c basic, @c extended, @c awk, @c grep, @c egrep
    * %set.
    */
-  enum syntax_option_type : unsigned int
-  {
-    /**
-     * Specifies that the matching of regular expressions against a character
-     * sequence shall be performed without regard to case.
-     */
-    icase      = 1 << _S_icase,
-
-    /**
-     * Specifies that when a regular expression is matched against a character
-     * container sequence, no sub-expression matches are to be stored in the
-     * supplied match_results structure.
-     */
-    nosubs     = 1 << _S_nosubs,
-
-    /**
-     * Specifies that the regular expression engine should pay more attention to
-     * the speed with which regular expressions are matched, and less to the
-     * speed with which regular expression objects are constructed. Otherwise
-     * it has no detectable effect on the program output.
-     */
-    optimize   = 1 << _S_optimize,
-
-    /**
-     * Specifies that character ranges of the form [a-b] should be locale
-     * sensitive.
-     */
-    collate    = 1 << _S_collate,
-
-    /**
-     * Specifies that the grammar recognized by the regular expression engine is
-     * that used by ECMAScript in ECMA-262 [Ecma International, ECMAScript
-     * Language Specification, Standard Ecma-262, third edition, 1999], as
-     * modified in section [28.13].  This grammar is similar to that defined
-     * in the PERL scripting language but extended with elements found in the
-     * POSIX regular expression grammar.
-     */
-    ECMAScript = 1 << _S_ECMAScript,
-
-    /**
-     * Specifies that the grammar recognized by the regular expression engine is
-     * that used by POSIX basic regular expressions in IEEE Std 1003.1-2001,
-     * Portable Operating System Interface (POSIX), Base Definitions and
-     * Headers, Section 9, Regular Expressions [IEEE, Information Technology --
-     * Portable Operating System Interface (POSIX), IEEE Standard 1003.1-2001].
-     */
-    basic      = 1 << _S_basic,
-
-    /**
-     * Specifies that the grammar recognized by the regular expression engine is
-     * that used by POSIX extended regular expressions in IEEE Std 1003.1-2001,
-     * Portable Operating System Interface (POSIX), Base Definitions and
-     * Headers, Section 9, Regular Expressions.
-     */
-    extended   = 1 << _S_extended,
-
-    /**
-     * Specifies that the grammar recognized by the regular expression engine is
-     * that used by POSIX utility awk in IEEE Std 1003.1-2001.  This option is
-     * identical to syntax_option_type extended, except that C-style escape
-     * sequences are supported.  These sequences are:
-     * \\\\, \\a, \\b, \\f, \\n, \\r, \\t , \\v, \\&apos,, &apos,,
-     * and \\ddd (where ddd is one, two, or three octal digits).
-     */
-    awk        = 1 << _S_awk,
-
-    /**
-     * Specifies that the grammar recognized by the regular expression engine is
-     * that used by POSIX utility grep in IEEE Std 1003.1-2001.  This option is
-     * identical to syntax_option_type basic, except that newlines are treated
-     * as whitespace.
-     */
-    grep       = 1 << _S_grep,
-
-    /**
-     * Specifies that the grammar recognized by the regular expression engine is
-     * that used by POSIX utility grep when given the -E option in
-     * IEEE Std 1003.1-2001.  This option is identical to syntax_option_type
-     * extended, except that newlines are treated as whitespace.
-     */
-    egrep      = 1 << _S_egrep,
-  };
 
-  constexpr inline syntax_option_type
-  operator&(syntax_option_type __a, syntax_option_type __b)
-  {
-    return (syntax_option_type)(static_cast<unsigned int>(__a)
-				& static_cast<unsigned int>(__b));
-  }
+  /**
+   * Specifies that the matching of regular expressions against a character
+   * sequence shall be performed without regard to case.
+   */
+  constexpr syntax_option_type icase = syntax_option_type::_S_icase;
 
-  constexpr inline syntax_option_type
-  operator|(syntax_option_type __a, syntax_option_type __b)
-  {
-    return (syntax_option_type)(static_cast<unsigned int>(__a)
-				| static_cast<unsigned int>(__b));
-  }
+  /**
+   * Specifies that when a regular expression is matched against a character
+   * container sequence, no sub-expression matches are to be stored in the
+   * supplied match_results structure.
+   */
+  constexpr syntax_option_type nosubs = syntax_option_type::_S_nosubs;
 
-  constexpr inline syntax_option_type
-  operator^(syntax_option_type __a, syntax_option_type __b)
-  {
-    return (syntax_option_type)(static_cast<unsigned int>(__a)
-				^ static_cast<unsigned int>(__b));
-  }
+  /**
+   * Specifies that the regular expression engine should pay more attention to
+   * the speed with which regular expressions are matched, and less to the
+   * speed with which regular expression objects are constructed. Otherwise
+   * it has no detectable effect on the program output.
+   */
+  constexpr syntax_option_type optimize = syntax_option_type::_S_optimize;
+
+  /**
+   * Specifies that character ranges of the form [a-b] should be locale
+   * sensitive.
+   */
+  constexpr syntax_option_type collate = syntax_option_type::_S_collate;
+
+  /**
+   * Specifies that the grammar recognized by the regular expression engine is
+   * that used by ECMAScript in ECMA-262 [Ecma International, ECMAScript
+   * Language Specification, Standard Ecma-262, third edition, 1999], as
+   * modified in section [28.13].  This grammar is similar to that defined
+   * in the PERL scripting language but extended with elements found in the
+   * POSIX regular expression grammar.
+   */
+  constexpr syntax_option_type ECMAScript = syntax_option_type::_S_ECMAScript;
 
-  constexpr inline syntax_option_type
-  operator~(syntax_option_type __a)
-  { return (syntax_option_type)(~static_cast<unsigned int>(__a)); }
+  /**
+   * Specifies that the grammar recognized by the regular expression engine is
+   * that used by POSIX basic regular expressions in IEEE Std 1003.1-2001,
+   * Portable Operating System Interface (POSIX), Base Definitions and
+   * Headers, Section 9, Regular Expressions [IEEE, Information Technology --
+   * Portable Operating System Interface (POSIX), IEEE Standard 1003.1-2001].
+   */
+  constexpr syntax_option_type basic = syntax_option_type::_S_basic;
 
-  inline syntax_option_type&
-  operator&=(syntax_option_type& __a, syntax_option_type __b)
-  { return __a = __a & __b; }
+  /**
+   * Specifies that the grammar recognized by the regular expression engine is
+   * that used by POSIX extended regular expressions in IEEE Std 1003.1-2001,
+   * Portable Operating System Interface (POSIX), Base Definitions and
+   * Headers, Section 9, Regular Expressions.
+   */
+  constexpr syntax_option_type extended = syntax_option_type::_S_extended;
 
-  inline syntax_option_type&
-  operator|=(syntax_option_type& __a, syntax_option_type __b)
-  { return __a = __a | __b; }
+  /**
+   * Specifies that the grammar recognized by the regular expression engine is
+   * that used by POSIX utility awk in IEEE Std 1003.1-2001.  This option is
+   * identical to syntax_option_type extended, except that C-style escape
+   * sequences are supported.  These sequences are:
+   * \\\\, \\a, \\b, \\f, \\n, \\r, \\t , \\v, \\&apos,, &apos,,
+   * and \\ddd (where ddd is one, two, or three octal digits).
+   */
+  constexpr syntax_option_type awk = syntax_option_type::_S_awk;
 
-  inline syntax_option_type&
-  operator^=(syntax_option_type& __a, syntax_option_type __b)
-  { return __a = __a ^ __b; }
+  /**
+   * Specifies that the grammar recognized by the regular expression engine is
+   * that used by POSIX utility grep in IEEE Std 1003.1-2001.  This option is
+   * identical to syntax_option_type basic, except that newlines are treated
+   * as whitespace.
+   */
+  constexpr syntax_option_type grep = syntax_option_type::_S_grep;
+
+  /**
+   * Specifies that the grammar recognized by the regular expression engine is
+   * that used by POSIX utility grep when given the -E option in
+   * IEEE Std 1003.1-2001.  This option is identical to syntax_option_type
+   * extended, except that newlines are treated as whitespace.
+   */
+  constexpr syntax_option_type egrep = syntax_option_type::_S_egrep;
 
   //@}
 
@@ -210,22 +244,98 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
    */
   //@{
 
-  enum __match_flag
+  class match_flag_type
   {
-    _S_not_bol,
-    _S_not_eol,
-    _S_not_bow,
-    _S_not_eow,
-    _S_any,
-    _S_not_null,
-    _S_continuous,
-    _S_prev_avail,
-    _S_sed,
-    _S_no_copy,
-    _S_first_only,
-    _S_match_flag_last
+  private:
+    enum __match_flag
+    {
+      _S_flag_match_not_bol,
+      _S_flag_match_not_eol,
+      _S_flag_match_not_bow,
+      _S_flag_match_not_eow,
+      _S_flag_match_any,
+      _S_flag_match_not_null,
+      _S_flag_match_continuous,
+      _S_flag_match_prev_avail,
+      _S_flag_format_sed,
+      _S_flag_format_no_copy,
+      _S_flag_format_first_only,
+      _S_flag_match_flag_last
+    };
+
+    constexpr
+    match_flag_type(unsigned int __flag) : _M_flag(__flag) { }
+
+  public:
+    enum _Flag : unsigned int
+    {
+      _S_match_default = 0,
+      _S_match_not_bol = 1 << _S_flag_match_not_bol,
+      _S_match_not_eol = 1 << _S_flag_match_not_eol,
+      _S_match_not_bow = 1 << _S_flag_match_not_bow,
+      _S_match_not_eow = 1 << _S_flag_match_not_eow,
+      _S_match_any = 1 << _S_flag_match_any,
+      _S_match_not_null = 1 << _S_flag_match_not_null,
+      _S_match_continuous = 1 << _S_flag_match_continuous,
+      _S_match_prev_avail = 1 << _S_flag_match_prev_avail,
+      _S_format_default = 0,
+      _S_format_sed = 1 << _S_flag_format_sed,
+      _S_format_no_copy = 1 << _S_flag_format_no_copy,
+      _S_format_first_only = 1 << _S_flag_format_first_only,
+    };
+
+    constexpr
+    match_flag_type(_Flag __flag = _S_match_default) : _M_flag(__flag) { }
+
+    constexpr
+    match_flag_type(const match_flag_type&) = default;
+
+    constexpr match_flag_type
+    operator&(match_flag_type __rhs) const
+    { return _M_flag & __rhs._M_flag; }
+
+    constexpr match_flag_type
+    operator|(match_flag_type __rhs) const
+    { return _M_flag | __rhs._M_flag; }
+
+    constexpr match_flag_type
+    operator^(match_flag_type __rhs) const
+    { return _M_flag ^ __rhs._M_flag; }
+
+    constexpr match_flag_type
+    operator~() const
+    { return ~_M_flag; }
+
+    match_flag_type&
+    operator&=(match_flag_type __rhs)
+    {
+      _M_flag &= __rhs._M_flag;
+      return *this;
+    }
+
+    match_flag_type&
+    operator|=(match_flag_type __rhs)
+    {
+      _M_flag |= __rhs._M_flag;
+      return *this;
+    }
+
+    match_flag_type&
+    operator^=(match_flag_type __rhs)
+    {
+      _M_flag ^= __rhs._M_flag;
+      return *this;
+    }
+
+    constexpr
+    operator bool() const
+    { return _M_flag; }
+
+  private:
+    unsigned int _M_flag;
   };
 
+
   /**
    * @brief This is a bitmask type indicating regex matching rules.
    *
@@ -233,148 +343,112 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
    * perform bitwise operations on these values and expect the right thing to
    * happen.
    */
-  enum match_flag_type : unsigned int
-  {
-    /**
-     * The default matching rules.
-     */
-    match_default     = 0,
-
-    /**
-     * The first character in the sequence [first, last) is treated as though it
-     * is not at the beginning of a line, so the character (^) in the regular
-     * expression shall not match [first, first).
-     */
-    match_not_bol     = 1 << _S_not_bol,
-
-    /**
-     * The last character in the sequence [first, last) is treated as though it
-     * is not at the end of a line, so the character ($) in the regular
-     * expression shall not match [last, last).
-     */
-    match_not_eol     = 1 << _S_not_eol,
-
-    /**
-     * The expression \\b is not matched against the sub-sequence
-     * [first,first).
-     */
-    match_not_bow     = 1 << _S_not_bow,
-
-    /**
-     * The expression \\b should not be matched against the sub-sequence
-     * [last,last).
-     */
-    match_not_eow     = 1 << _S_not_eow,
-
-    /**
-     * If more than one match is possible then any match is an acceptable
-     * result.
-     */
-    match_any         = 1 << _S_any,
-
-    /**
-     * The expression does not match an empty sequence.
-     */
-    match_not_null    = 1 << _S_not_null,
-
-    /**
-     * The expression only matches a sub-sequence that begins at first .
-     */
-    match_continuous  = 1 << _S_continuous,
-
-    /**
-     * --first is a valid iterator position.  When this flag is set then the
-     * flags match_not_bol and match_not_bow are ignored by the regular
-     * expression algorithms 28.11 and iterators 28.12.
-     */
-    match_prev_avail  = 1 << _S_prev_avail,
-
-    /**
-     * When a regular expression match is to be replaced by a new string, the
-     * new string is constructed using the rules used by the ECMAScript replace
-     * function in ECMA- 262 [Ecma International, ECMAScript Language
-     * Specification, Standard Ecma-262, third edition, 1999], part 15.5.4.11
-     * String.prototype.replace. In addition, during search and replace
-     * operations all non-overlapping occurrences of the regular expression
-     * are located and replaced, and sections of the input that did not match
-     * the expression are copied unchanged to the output string.
-     *
-     * Format strings (from ECMA-262 [15.5.4.11]):
-     * @li $$  The dollar-sign itself ($)
-     * @li $&  The matched substring.
-     * @li $`  The portion of @a string that precedes the matched substring.
-     *         This would be match_results::prefix().
-     * @li $'  The portion of @a string that follows the matched substring.
-     *         This would be match_results::suffix().
-     * @li $n  The nth capture, where n is in [1,9] and $n is not followed by a
-     *         decimal digit.  If n <= match_results::size() and the nth capture
-     *         is undefined, use the empty string instead.  If n >
-     *         match_results::size(), the result is implementation-defined.
-     * @li $nn The nnth capture, where nn is a two-digit decimal number on
-     *         [01, 99].  If nn <= match_results::size() and the nth capture is
-     *         undefined, use the empty string instead. If
-     *         nn > match_results::size(), the result is implementation-defined.
-     */
-    format_default    = 0,
-
-    /**
-     * When a regular expression match is to be replaced by a new string, the
-     * new string is constructed using the rules used by the POSIX sed utility
-     * in IEEE Std 1003.1- 2001 [IEEE, Information Technology -- Portable
-     * Operating System Interface (POSIX), IEEE Standard 1003.1-2001].
-     */
-    format_sed        = 1 << _S_sed,
-
-    /**
-     * During a search and replace operation, sections of the character
-     * container sequence being searched that do not match the regular
-     * expression shall not be copied to the output string.
-     */
-    format_no_copy    = 1 << _S_no_copy,
-
-    /**
-     * When specified during a search and replace operation, only the first
-     * occurrence of the regular expression shall be replaced.
-     */
-    format_first_only = 1 << _S_first_only,
-  };
 
-  constexpr inline match_flag_type
-  operator&(match_flag_type __a, match_flag_type __b)
-  {
-    return (match_flag_type)(static_cast<unsigned int>(__a)
-				& static_cast<unsigned int>(__b));
-  }
+  /**
+   * The default matching rules.
+   */
+  const match_flag_type match_default = match_flag_type::_S_match_default;
 
-  constexpr inline match_flag_type
-  operator|(match_flag_type __a, match_flag_type __b)
-  {
-    return (match_flag_type)(static_cast<unsigned int>(__a)
-				| static_cast<unsigned int>(__b));
-  }
+  /**
+   * The first character in the sequence [first, last) is treated as though it
+   * is not at the beginning of a line, so the character (^) in the regular
+   * expression shall not match [first, first).
+   */
+  constexpr match_flag_type match_not_bol = match_flag_type::_S_match_not_bol;
 
-  constexpr inline match_flag_type
-  operator^(match_flag_type __a, match_flag_type __b)
-  {
-    return (match_flag_type)(static_cast<unsigned int>(__a)
-				^ static_cast<unsigned int>(__b));
-  }
+  /**
+   * The last character in the sequence [first, last) is treated as though it
+   * is not at the end of a line, so the character ($) in the regular
+   * expression shall not match [last, last).
+   */
+  constexpr match_flag_type match_not_eol = match_flag_type::_S_match_not_eol;
+
+  /**
+   * The expression \\b is not matched against the sub-sequence
+   * [first,first).
+   */
+  constexpr match_flag_type match_not_bow = match_flag_type::_S_match_not_bow;
+
+  /**
+   * The expression \\b should not be matched against the sub-sequence
+   * [last,last).
+   */
+  constexpr match_flag_type match_not_eow = match_flag_type::_S_match_not_eow;
+
+  /**
+   * If more than one match is possible then any match is an acceptable
+   * result.
+   */
+  constexpr match_flag_type match_any = match_flag_type::_S_match_any;
+
+  /**
+   * The expression does not match an empty sequence.
+   */
+  constexpr match_flag_type match_not_null = match_flag_type::_S_match_not_null;
 
-  constexpr inline match_flag_type
-  operator~(match_flag_type __a)
-  { return (match_flag_type)(~static_cast<unsigned int>(__a)); }
+  /**
+   * The expression only matches a sub-sequence that begins at first .
+   */
+  constexpr match_flag_type match_continuous =
+    match_flag_type::_S_match_continuous;
 
-  inline match_flag_type&
-  operator&=(match_flag_type& __a, match_flag_type __b)
-  { return __a = __a & __b; }
+  /**
+   * --first is a valid iterator position.  When this flag is set then the
+   * flags match_not_bol and match_not_bow are ignored by the regular
+   * expression algorithms 28.11 and iterators 28.12.
+   */
+  constexpr match_flag_type match_prev_avail =
+    match_flag_type::_S_match_prev_avail;
 
-  inline match_flag_type&
-  operator|=(match_flag_type& __a, match_flag_type __b)
-  { return __a = __a | __b; }
+  /**
+   * When a regular expression match is to be replaced by a new string, the
+   * new string is constructed using the rules used by the ECMAScript replace
+   * function in ECMA- 262 [Ecma International, ECMAScript Language
+   * Specification, Standard Ecma-262, third edition, 1999], part 15.5.4.11
+   * String.prototype.replace. In addition, during search and replace
+   * operations all non-overlapping occurrences of the regular expression
+   * are located and replaced, and sections of the input that did not match
+   * the expression are copied unchanged to the output string.
+   *
+   * Format strings (from ECMA-262 [15.5.4.11]):
+   * @li $$  The dollar-sign itself ($)
+   * @li $&  The matched substring.
+   * @li $`  The portion of @a string that precedes the matched substring.
+   *         This would be match_results::prefix().
+   * @li $'  The portion of @a string that follows the matched substring.
+   *         This would be match_results::suffix().
+   * @li $n  The nth capture, where n is in [1,9] and $n is not followed by a
+   *         decimal digit.  If n <= match_results::size() and the nth capture
+   *         is undefined, use the empty string instead.  If n >
+   *         match_results::size(), the result is implementation-defined.
+   * @li $nn The nnth capture, where nn is a two-digit decimal number on
+   *         [01, 99].  If nn <= match_results::size() and the nth capture is
+   *         undefined, use the empty string instead. If
+   *         nn > match_results::size(), the result is implementation-defined.
+   */
+  constexpr match_flag_type format_default = match_flag_type::_S_format_default;
 
-  inline match_flag_type&
-  operator^=(match_flag_type& __a, match_flag_type __b)
-  { return __a = __a ^ __b; }
+  /**
+   * When a regular expression match is to be replaced by a new string, the
+   * new string is constructed using the rules used by the POSIX sed utility
+   * in IEEE Std 1003.1- 2001 [IEEE, Information Technology -- Portable
+   * Operating System Interface (POSIX), IEEE Standard 1003.1-2001].
+   */
+  constexpr match_flag_type format_sed = match_flag_type::_S_format_sed;
+
+  /**
+   * During a search and replace operation, sections of the character
+   * container sequence being searched that do not match the regular
+   * expression shall not be copied to the output string.
+   */
+  constexpr match_flag_type format_no_copy = match_flag_type::_S_format_no_copy;
+
+  /**
+   * When specified during a search and replace operation, only the first
+   * occurrence of the regular expression shall be replaced.
+   */
+  constexpr match_flag_type format_first_only =
+    match_flag_type::_S_format_first_only;
 
   //@}
 
