sl@0: /////////////////////////////////////////////////////////////////////////////// sl@0: /// \file regex_constants.hpp sl@0: /// Contains definitions for the syntax_option_type, match_flag_type and sl@0: /// error_type enumerations. sl@0: // sl@0: // Copyright 2004 Eric Niebler. Distributed under the Boost sl@0: // Software License, Version 1.0. (See accompanying file sl@0: // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) sl@0: sl@0: #ifndef BOOST_XPRESSIVE_REGEX_CONSTANTS_HPP_EAN_10_04_2005 sl@0: #define BOOST_XPRESSIVE_REGEX_CONSTANTS_HPP_EAN_10_04_2005 sl@0: sl@0: // MS compatible compilers support #pragma once sl@0: #if defined(_MSC_VER) && (_MSC_VER >= 1020) sl@0: # pragma once sl@0: #endif sl@0: sl@0: #include sl@0: sl@0: #ifndef BOOST_XPRESSIVE_DOXYGEN_INVOKED sl@0: # define icase icase_ sl@0: #endif sl@0: sl@0: namespace boost { namespace xpressive { namespace regex_constants sl@0: { sl@0: sl@0: /// Flags used to customize the regex syntax sl@0: /// sl@0: enum syntax_option_type sl@0: { sl@0: // these flags are required: sl@0: sl@0: ECMAScript = 0, ///< Specifies that the grammar recognized by the regular expression sl@0: ///< engine uses its normal semantics: that is the same as that given sl@0: ///< in the ECMA-262, ECMAScript Language Specification, Chapter 15 sl@0: ///< part 10, RegExp (Regular Expression) Objects (FWD.1). sl@0: ///< sl@0: icase = 1 << 1, ///< Specifies that matching of regular expressions against a character sl@0: ///< container sequence shall be performed without regard to case. sl@0: ///< sl@0: nosubs = 1 << 2, ///< Specifies that when a regular expression is matched against a sl@0: ///< character container sequence, then no sub-expression matches are to sl@0: ///< be stored in the supplied match_results structure. sl@0: ///< sl@0: optimize = 1 << 3, ///< Specifies that the regular expression engine should pay more sl@0: ///< attention to the speed with which regular expressions are matched, sl@0: ///< and less to the speed with which regular expression objects are sl@0: ///< constructed. Otherwise it has no detectable effect on the program sl@0: ///< output. sl@0: ///< sl@0: collate = 1 << 4, ///< Specifies that character ranges of the form "[a-b]" should be sl@0: ///< locale sensitive. sl@0: ///< sl@0: sl@0: // These flags are optional. If the functionality is supported sl@0: // then the flags shall take these names. sl@0: sl@0: //basic = 1 << 5, ///< Specifies that the grammar recognized by the regular expression sl@0: // ///< engine is the same as that used by POSIX basic regular expressions sl@0: // ///< in IEEE Std 1003.1-2001, Portable Operating System Interface sl@0: // ///< (POSIX), Base Definitions and Headers, Section 9, Regular sl@0: // ///< Expressions (FWD.1). sl@0: // ///< sl@0: //extended = 1 << 6, ///< Specifies that the grammar recognized by the regular expression sl@0: // ///< engine is the same as that used by POSIX extended regular sl@0: // ///< expressions in IEEE Std 1003.1-2001, Portable Operating System sl@0: // ///< Interface (POSIX), Base Definitions and Headers, Section 9, sl@0: // ///< Regular Expressions (FWD.1). sl@0: // ///< sl@0: //awk = 1 << 7, ///< Specifies that the grammar recognized by the regular expression sl@0: // ///< engine is the same as that used by POSIX utility awk in IEEE Std sl@0: // ///< 1003.1-2001, Portable Operating System Interface (POSIX), Shells sl@0: // ///< and Utilities, Section 4, awk (FWD.1). sl@0: // ///< sl@0: //grep = 1 << 8, ///< Specifies that the grammar recognized by the regular expression sl@0: // ///< engine is the same as that used by POSIX utility grep in IEEE Std sl@0: // ///< 1003.1-2001, Portable Operating System Interface (POSIX), sl@0: // ///< Shells and Utilities, Section 4, Utilities, grep (FWD.1). sl@0: // ///< sl@0: //egrep = 1 << 9, ///< Specifies that the grammar recognized by the regular expression sl@0: // ///< engine is the same as that used by POSIX utility grep when given sl@0: // ///< the -E option in IEEE Std 1003.1-2001, Portable Operating System sl@0: // ///< Interface (POSIX), Shells and Utilities, Section 4, Utilities, sl@0: // ///< grep (FWD.1). sl@0: // ///< sl@0: sl@0: // these flags are specific to xpressive, and they help with perl compliance. sl@0: sl@0: single_line = 1 << 10, ///< Specifies that the ^ and \$ metacharacters DO NOT match at sl@0: ///< internal line breaks. Note that this is the opposite of the sl@0: ///< perl default. It is the inverse of perl's /m (multi-line) sl@0: ///< modifier. sl@0: ///< sl@0: not_dot_null = 1 << 11, ///< Specifies that the . metacharacter does not match the null sl@0: ///< character \\0. sl@0: ///< sl@0: not_dot_newline = 1 << 12, ///< Specifies that the . metacharacter does not match the sl@0: ///< newline character \\n. sl@0: ///< sl@0: ignore_white_space = 1 << 13 ///< Specifies that non-escaped white-space is not significant. sl@0: ///< sl@0: }; sl@0: sl@0: /// Flags used to customize the behavior of the regex algorithms sl@0: /// sl@0: enum match_flag_type sl@0: { sl@0: match_default = 0, ///< Specifies that matching of regular expressions proceeds sl@0: ///< without any modification of the normal rules used in sl@0: ///< ECMA-262, ECMAScript Language Specification, Chapter 15 sl@0: ///< part 10, RegExp (Regular Expression) Objects (FWD.1) sl@0: ///< sl@0: match_not_bol = 1 << 1, ///< Specifies that the expression "^" should not be matched sl@0: ///< against the sub-sequence [first,first). sl@0: ///< sl@0: match_not_eol = 1 << 2, ///< Specifies that the expression "\$" should not be sl@0: ///< matched against the sub-sequence [last,last). sl@0: ///< sl@0: match_not_bow = 1 << 3, ///< Specifies that the expression "\\b" should not be sl@0: ///< matched against the sub-sequence [first,first). sl@0: ///< sl@0: match_not_eow = 1 << 4, ///< Specifies that the expression "\\b" should not be sl@0: ///< matched against the sub-sequence [last,last). sl@0: ///< sl@0: match_any = 1 << 7, ///< Specifies that if more than one match is possible then sl@0: ///< any match is an acceptable result. sl@0: ///< sl@0: match_not_null = 1 << 8, ///< Specifies that the expression can not be matched sl@0: ///< against an empty sequence. sl@0: ///< sl@0: match_continuous = 1 << 10, ///< Specifies that the expression must match a sub-sequence sl@0: ///< that begins at first. sl@0: ///< sl@0: match_partial = 1 << 11, ///< Specifies that if no match can be found, then it is sl@0: ///< acceptable to return a match [from, last) where sl@0: ///< from!=last, if there exists some sequence of characters sl@0: ///< [from,to) of which [from,last) is a prefix, and which sl@0: ///< would result in a full match. sl@0: ///< sl@0: match_prev_avail = 1 << 12, ///< Specifies that --first is a valid iterator position, sl@0: ///< when this flag is set then the flags match_not_bol sl@0: ///< and match_not_bow are ignored by the regular expression sl@0: ///< algorithms (RE.7) and iterators (RE.8). sl@0: ///< sl@0: format_default = 0, ///< Specifies that when a regular expression match is to be sl@0: ///< replaced by a new string, that the new string is sl@0: ///< constructed using the rules used by the ECMAScript sl@0: ///< replace function in ECMA-262, ECMAScript Language sl@0: ///< Specification, Chapter 15 part 5.4.11 sl@0: ///< String.prototype.replace. (FWD.1). In addition during sl@0: ///< search and replace operations then all non-overlapping sl@0: ///< occurrences of the regular expression are located and sl@0: ///< replaced, and sections of the input that did not match sl@0: ///< the expression, are copied unchanged to the output sl@0: ///< string. sl@0: ///< sl@0: //format_sed = 1 << 13, ///< Specifies that when a regular expression match is to be sl@0: // ///< replaced by a new string, that the new string is sl@0: // ///< constructed using the rules used by the Unix sed sl@0: // ///< utility in IEEE Std 1003.1-2001, Portable Operating sl@0: // ///< SystemInterface (POSIX), Shells and Utilities. sl@0: // ///< sl@0: //format_perl = 1 << 14, ///< Specifies that when a regular expression match is to be sl@0: // ///< replaced by a new string, that the new string is sl@0: // ///< constructed using an implementation defined superset sl@0: // ///< of the rules used by the ECMAScript replace function in sl@0: // ///< ECMA-262, ECMAScript Language Specification, Chapter 15 sl@0: // ///< part 5.4.11 String.prototype.replace (FWD.1). sl@0: // ///< sl@0: format_no_copy = 1 << 15, ///< When specified during a search and replace operation, sl@0: ///< then sections of the character container sequence being sl@0: ///< searched that do match the regular expression, are not sl@0: ///< copied to the output string. sl@0: ///< sl@0: format_first_only = 1 << 16, ///< When specified during a search and replace operation, sl@0: ///< then only the first occurrence of the regular sl@0: ///< expression is replaced. sl@0: ///< sl@0: format_literal = 1 << 17 ///< Treat the format string as a literal. sl@0: ///< sl@0: }; sl@0: sl@0: /// Error codes used by the regex_error type sl@0: /// sl@0: enum error_type sl@0: { sl@0: error_collate, ///< The expression contained an invalid collating element name. sl@0: ///< sl@0: error_ctype, ///< The expression contained an invalid character class name. sl@0: ///< sl@0: error_escape, ///< The expression contained an invalid escaped character, sl@0: ///< or a trailing escape. sl@0: ///< sl@0: error_subreg, ///< The expression contained an invalid back-reference. sl@0: ///< sl@0: error_brack, ///< The expression contained mismatched [ and ]. sl@0: ///< sl@0: error_paren, ///< The expression contained mismatched (and). sl@0: ///< sl@0: error_brace, ///< The expression contained mismatched { and } sl@0: ///< sl@0: error_badbrace, ///< The expression contained an invalid range in a {} expression. sl@0: ///< sl@0: error_range, ///< The expression contained an invalid character range, for sl@0: ///< example [b-a]. sl@0: ///< sl@0: error_space, ///< There was insufficient memory to convert the expression into a sl@0: ///< finite state machine. sl@0: ///< sl@0: error_badrepeat, ///< One of *?+{ was not preceded by a valid regular expression. sl@0: ///< sl@0: error_complexity, ///< The complexity of an attempted match against a regular sl@0: ///< expression exceeded a pre-set level. sl@0: ///< sl@0: error_stack, ///< There was insufficient memory to determine whether the regular sl@0: ///< expression could match the specified character sequence. sl@0: ///< sl@0: error_badref, ///< An nested regex is uninitialized. sl@0: ///< sl@0: error_badlookbehind, ///< An attempt to create a variable-width look-behind assertion sl@0: ///< was detected. sl@0: ///< sl@0: error_internal ///< An internal error has occured. sl@0: ///< sl@0: }; sl@0: sl@0: /// INTERNAL ONLY sl@0: inline syntax_option_type operator &(syntax_option_type b1, syntax_option_type b2) sl@0: { sl@0: return static_cast( sl@0: static_cast(b1) & static_cast(b2)); sl@0: } sl@0: sl@0: /// INTERNAL ONLY sl@0: inline syntax_option_type operator |(syntax_option_type b1, syntax_option_type b2) sl@0: { sl@0: return static_cast(static_cast(b1) | static_cast(b2)); sl@0: } sl@0: sl@0: /// INTERNAL ONLY sl@0: inline syntax_option_type operator ^(syntax_option_type b1, syntax_option_type b2) sl@0: { sl@0: return static_cast(static_cast(b1) ^ static_cast(b2)); sl@0: } sl@0: sl@0: /// INTERNAL ONLY sl@0: inline syntax_option_type operator ~(syntax_option_type b) sl@0: { sl@0: return static_cast(~static_cast(b)); sl@0: } sl@0: sl@0: /// INTERNAL ONLY sl@0: inline match_flag_type operator &(match_flag_type b1, match_flag_type b2) sl@0: { sl@0: return static_cast(static_cast(b1) & static_cast(b2)); sl@0: } sl@0: sl@0: /// INTERNAL ONLY sl@0: inline match_flag_type operator |(match_flag_type b1, match_flag_type b2) sl@0: { sl@0: return static_cast(static_cast(b1) | static_cast(b2)); sl@0: } sl@0: sl@0: /// INTERNAL ONLY sl@0: inline match_flag_type operator ^(match_flag_type b1, match_flag_type b2) sl@0: { sl@0: return static_cast(static_cast(b1) ^ static_cast(b2)); sl@0: } sl@0: sl@0: /// INTERNAL ONLY sl@0: inline match_flag_type operator ~(match_flag_type b) sl@0: { sl@0: return static_cast(~static_cast(b)); sl@0: } sl@0: sl@0: }}} // namespace boost::xpressive::regex_constants sl@0: sl@0: #ifndef BOOST_XPRESSIVE_DOXYGEN_INVOKED sl@0: # undef icase sl@0: #endif sl@0: sl@0: #endif