From patchwork Sun Mar 15 08:09:05 2015 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Tim Shen X-Patchwork-Id: 450251 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Received: from sourceware.org (server1.sourceware.org [209.132.180.131]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by ozlabs.org (Postfix) with ESMTPS id 1F74B14009B for ; Sun, 15 Mar 2015 19:09:36 +1100 (AEDT) Authentication-Results: ozlabs.org; dkim=pass reason="1024-bit key; unprotected key" header.d=gcc.gnu.org header.i=@gcc.gnu.org header.b=Fo4SrZlD; dkim-adsp=none (unprotected policy); dkim-atps=neutral DomainKey-Signature: a=rsa-sha1; c=nofws; d=gcc.gnu.org; h=list-id :list-unsubscribe:list-archive:list-post:list-help:sender :mime-version:date:message-id:subject:from:to:content-type; q= dns; s=default; b=Wi5EfO449ZJz3/VcorGiNj8cWHkkmu5bPl00WVa62mYDiZ ixDRkTv+2Hlh+zrW+miayxmLkIg5m5w9mvg6aV2hXZVPPuEdhsnf068okmfpS6nr JKZHUU8Gm3bIrqWUlFfiTc5K6R+iIlXttsy2JY7NHvovMj9ZAESJirID8jKbU= DKIM-Signature: v=1; a=rsa-sha1; c=relaxed; d=gcc.gnu.org; h=list-id :list-unsubscribe:list-archive:list-post:list-help:sender :mime-version:date:message-id:subject:from:to:content-type; s= default; bh=bwmhvBUSRiHlCtOskLQRkNyvE1E=; b=Fo4SrZlD1t4vlFT8UKz4 VdlaQ9Z/iNbFkqivvoqIk2ycaGdlE8F5hdnQHUoj44PP0owXZkyGYbZ/Vzk/hz85 Ol+UMultBjdOtNiTAEveZxazcAzOQLRBMrv7eUR2z4Fq06gicFPTX/LwI1tNGOe4 ZprQSBIVXZK+p84l3EsESw8= Received: (qmail 102470 invoked by alias); 15 Mar 2015 08:09:12 -0000 Mailing-List: contact gcc-patches-help@gcc.gnu.org; run by ezmlm Precedence: bulk List-Id: List-Unsubscribe: List-Archive: List-Post: List-Help: Sender: gcc-patches-owner@gcc.gnu.org Delivered-To: mailing list gcc-patches@gcc.gnu.org Received: (qmail 102447 invoked by uid 89); 15 Mar 2015 08:09:10 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=0.3 required=5.0 tests=AWL, BAYES_00, FREEMAIL_ENVFROM_END_DIGIT, FREEMAIL_FROM, KAM_FROM_URIBL_PCCC, RCVD_IN_DNSWL_LOW, SPF_PASS autolearn=no version=3.3.2 X-Spam-User: qpsmtpd, 2 recipients X-HELO: mail-qc0-f176.google.com Received: from mail-qc0-f176.google.com (HELO mail-qc0-f176.google.com) (209.85.216.176) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with (AES128-GCM-SHA256 encrypted) ESMTPS; Sun, 15 Mar 2015 08:09:07 +0000 Received: by qcto4 with SMTP id o4so21039766qct.3; Sun, 15 Mar 2015 01:09:05 -0700 (PDT) MIME-Version: 1.0 X-Received: by 10.55.23.84 with SMTP id i81mr46642971qkh.51.1426406945179; Sun, 15 Mar 2015 01:09:05 -0700 (PDT) Received: by 10.96.151.226 with HTTP; Sun, 15 Mar 2015 01:09:05 -0700 (PDT) Date: Sun, 15 Mar 2015 01:09:05 -0700 Message-ID: Subject: [Patch, libstdc++/65420] Use constexpr variables as regex_constans flags From: Tim Shen To: "libstdc++" , gcc-patches 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! 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 + constexpr regex_constants::syntax_option_type + basic_regex<_Ch_type, _Rx_traits>::icase; + + template + constexpr regex_constants::syntax_option_type + basic_regex<_Ch_type, _Rx_traits>::nosubs; + + template + constexpr regex_constants::syntax_option_type + basic_regex<_Ch_type, _Rx_traits>::optimize; + + template + constexpr regex_constants::syntax_option_type + basic_regex<_Ch_type, _Rx_traits>::collate; + + template + constexpr regex_constants::syntax_option_type + basic_regex<_Ch_type, _Rx_traits>::ECMAScript; + + template + constexpr regex_constants::syntax_option_type + basic_regex<_Ch_type, _Rx_traits>::basic; + + template + constexpr regex_constants::syntax_option_type + basic_regex<_Ch_type, _Rx_traits>::extended; + + template + constexpr regex_constants::syntax_option_type + basic_regex<_Ch_type, _Rx_traits>::awk; + + template + constexpr regex_constants::syntax_option_type + basic_regex<_Ch_type, _Rx_traits>::grep; + + template + constexpr regex_constants::syntax_option_type + basic_regex<_Ch_type, _Rx_traits>::egrep; + /** @brief Standard regular expressions. */ typedef basic_regex 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(__a) - & static_cast(__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(__a) - | static_cast(__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(__a) - ^ static_cast(__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(__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(__a) - & static_cast(__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(__a) - | static_cast(__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(__a) - ^ static_cast(__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(__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; //@}