[Patch, libstdc++/65420] Use constexpr variables as regex_constans flags
Tim Shen
timshen91@gmail.com
Sun Mar 15 08:09:00 GMT 2015
Did a little bit refectoring on regex_constants, so that users won't
be polluted too much (they are not enum types anymore).
Bootstrapped and tested.
Thanks!
--
Regards,
Tim Shen
-------------- next part --------------
commit 5cd86b408ef0a9cba1a21a3018c797d9e245d158
Author: Tim Shen <timshen@google.com>
Date: Sat Mar 14 23:05:05 2015 -0700
PR libstdc++/65420
* include/bits/regex.h: Add definition for static constexpr variables.
* include/bits/regex_constants.h: Change flags to constexpr variables.
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;
//@}
More information about the Libstdc++
mailing list