| Home | Libraries | People | FAQ | More

## Type match_flag_type

boost::xpressive::regex_constants::match_flag_type

## Synopsis

    // In header: <boost/xpressive/regex_constants.hpp>

    enum match_flag_type { match_default = = 0, match_not_bol = = 1 << 1,
                           match_not_eol = = 1 << 2, match_not_bow = = 1 << 3,
                           match_not_eow = = 1 << 4, match_any = = 1 << 7,
                           match_not_null = = 1 << 8,
                           match_continuous = = 1 << 10,
                           match_partial = = 1 << 11,
                           match_prev_avail = = 1 << 12, format_default = = 0,
                           format_sed = = 1 << 13, format_perl = = 1 << 14,
                           format_no_copy = = 1 << 15,
                           format_first_only = = 1 << 16,
                           format_literal = = 1 << 17, format_all = = 1 << 18 };

## Description

Flags used to customize the behavior of the regex algorithms

`match_default`

  Specifies that matching of regular expressions proceeds without any modification of the normal rules used in ECMA-262, ECMAScript Language Specification, Chapter 15 part 10, RegExp (Regular Expression) Objects (FWD.1)

`match_not_bol`

  Specifies that the expression "^" should not be matched against the sub-sequence [first,first).

`match_not_eol`

  Specifies that the expression "\$" should not be matched against the sub-sequence [last,last).

`match_not_bow`

  Specifies that the expression "\\b" should not be matched against the sub-sequence [first,first).

`match_not_eow`

  Specifies that the expression "\\b" should not be matched against the sub-sequence [last,last).

`match_any`

  Specifies that if more than one match is possible then any match is an acceptable result.

`match_not_null`

  Specifies that the expression can not be matched against an empty sequence.

`match_continuous`

  Specifies that the expression must match a sub-sequence that begins at first.

`match_partial`

  Specifies that if no match can be found, then it is acceptable to return a match [from, last) where from != last, if there exists some sequence of characters [from,to) of which [from,last) is a prefix, and which would result in a full match.

`match_prev_avail`

  Specifies that <ndash></ndash>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 (RE.7) and iterators (RE.8).

`format_default`

  Specifies that when a regular expression match is to be replaced by a new string, that the new string is constructed using the rules used by the ECMAScript replace function in ECMA-262, ECMAScript Language Specification, Chapter 15 part 5.4.11 String.prototype.replace. (FWD.1). In addition during search and replace operations then 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_sed`

  Specifies that when a regular expression match is to be replaced by a new string, that the new string is constructed using the rules used by the Unix sed utility in IEEE Std 1003.1-2001, Portable Operating SystemInterface (POSIX), Shells and Utilities.

`format_perl`

  Specifies that when a regular expression match is to be replaced by a new string, that the new string is constructed using an implementation defined superset of the rules used by the ECMAScript replace function in ECMA-262, ECMAScript Language Specification, Chapter 15 part 5.4.11 String.prototype.replace (FWD.1).

`format_no_copy`

  When specified during a search and replace operation, then sections of the character container sequence being searched that do match the regular expression, are not copied to the output string.

`format_first_only`

  When specified during a search and replace operation, then only the first occurrence of the regular expression is replaced.

`format_literal`

  Treat the format string as a literal.

`format_all`

  Specifies that all syntax extensions are enabled, including conditional (?ddexpression1:expression2) replacements.