295 lines
17 KiB
C++
295 lines
17 KiB
C++
///////////////////////////////////////////////////////////////////////////////
|
|
/// \file regex_constants.hpp
|
|
/// Contains definitions for the syntax_option_type, match_flag_type and
|
|
/// error_type enumerations.
|
|
//
|
|
// Copyright 2008 Eric Niebler. Distributed under the Boost
|
|
// Software License, Version 1.0. (See accompanying file
|
|
// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
|
|
|
#ifndef BOOST_XPRESSIVE_REGEX_CONSTANTS_HPP_EAN_10_04_2005
|
|
#define BOOST_XPRESSIVE_REGEX_CONSTANTS_HPP_EAN_10_04_2005
|
|
|
|
// MS compatible compilers support #pragma once
|
|
#if defined(_MSC_VER)
|
|
# pragma once
|
|
#endif
|
|
|
|
#include <boost/mpl/identity.hpp>
|
|
|
|
#ifndef BOOST_XPRESSIVE_DOXYGEN_INVOKED
|
|
# define icase icase_
|
|
#endif
|
|
|
|
namespace boost { namespace xpressive { namespace regex_constants
|
|
{
|
|
|
|
/// Flags used to customize the regex syntax
|
|
///
|
|
enum syntax_option_type
|
|
{
|
|
// these flags are required:
|
|
|
|
ECMAScript = 0, ///< Specifies that the grammar recognized by the regular expression
|
|
///< engine uses its normal semantics: that is the same as that given
|
|
///< in the ECMA-262, ECMAScript Language Specification, Chapter 15
|
|
///< part 10, RegExp (Regular Expression) Objects (FWD.1).
|
|
///<
|
|
icase = 1 << 1, ///< Specifies that matching of regular expressions against a character
|
|
///< container sequence shall be performed without regard to case.
|
|
///<
|
|
nosubs = 1 << 2, ///< Specifies that when a regular expression is matched against a
|
|
///< character container sequence, then no sub-expression matches are to
|
|
///< be stored in the supplied match_results structure.
|
|
///<
|
|
optimize = 1 << 3, ///< 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.
|
|
///<
|
|
collate = 1 << 4, ///< Specifies that character ranges of the form "[a-b]" should be
|
|
///< locale sensitive.
|
|
///<
|
|
|
|
// These flags are optional. If the functionality is supported
|
|
// then the flags shall take these names.
|
|
|
|
//basic = 1 << 5, ///< Specifies that the grammar recognized by the regular expression
|
|
// ///< engine is the same as 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 (FWD.1).
|
|
// ///<
|
|
//extended = 1 << 6, ///< Specifies that the grammar recognized by the regular expression
|
|
// ///< engine is the same as 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 (FWD.1).
|
|
// ///<
|
|
//awk = 1 << 7, ///< Specifies that the grammar recognized by the regular expression
|
|
// ///< engine is the same as that used by POSIX utility awk in IEEE Std
|
|
// ///< 1003.1-2001, Portable Operating System Interface (POSIX), Shells
|
|
// ///< and Utilities, Section 4, awk (FWD.1).
|
|
// ///<
|
|
//grep = 1 << 8, ///< Specifies that the grammar recognized by the regular expression
|
|
// ///< engine is the same as that used by POSIX utility grep in IEEE Std
|
|
// ///< 1003.1-2001, Portable Operating System Interface (POSIX),
|
|
// ///< Shells and Utilities, Section 4, Utilities, grep (FWD.1).
|
|
// ///<
|
|
//egrep = 1 << 9, ///< Specifies that the grammar recognized by the regular expression
|
|
// ///< engine is the same as that used by POSIX utility grep when given
|
|
// ///< the -E option in IEEE Std 1003.1-2001, Portable Operating System
|
|
// ///< Interface (POSIX), Shells and Utilities, Section 4, Utilities,
|
|
// ///< grep (FWD.1).
|
|
// ///<
|
|
|
|
// these flags are specific to xpressive, and they help with perl compliance.
|
|
|
|
single_line = 1 << 10, ///< Specifies that the ^ and \$ metacharacters DO NOT match at
|
|
///< internal line breaks. Note that this is the opposite of the
|
|
///< perl default. It is the inverse of perl's /m (multi-line)
|
|
///< modifier.
|
|
///<
|
|
not_dot_null = 1 << 11, ///< Specifies that the . metacharacter does not match the null
|
|
///< character \\0.
|
|
///<
|
|
not_dot_newline = 1 << 12, ///< Specifies that the . metacharacter does not match the
|
|
///< newline character \\n.
|
|
///<
|
|
ignore_white_space = 1 << 13 ///< Specifies that non-escaped white-space is not significant.
|
|
///<
|
|
};
|
|
|
|
/// Flags used to customize the behavior of the regex algorithms
|
|
///
|
|
enum match_flag_type
|
|
{
|
|
match_default = 0, ///< 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 = 1 << 1, ///< Specifies that the expression "^" should not be matched
|
|
///< against the sub-sequence [first,first).
|
|
///<
|
|
match_not_eol = 1 << 2, ///< Specifies that the expression "\$" should not be
|
|
///< matched against the sub-sequence [last,last).
|
|
///<
|
|
match_not_bow = 1 << 3, ///< Specifies that the expression "\\b" should not be
|
|
///< matched against the sub-sequence [first,first).
|
|
///<
|
|
match_not_eow = 1 << 4, ///< Specifies that the expression "\\b" should not be
|
|
///< matched against the sub-sequence [last,last).
|
|
///<
|
|
match_any = 1 << 7, ///< Specifies that if more than one match is possible then
|
|
///< any match is an acceptable result.
|
|
///<
|
|
match_not_null = 1 << 8, ///< Specifies that the expression can not be matched
|
|
///< against an empty sequence.
|
|
///<
|
|
match_continuous = 1 << 10, ///< Specifies that the expression must match a sub-sequence
|
|
///< that begins at first.
|
|
///<
|
|
match_partial = 1 << 11, ///< 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 = 1 << 12, ///< Specifies that --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 = 0, ///< 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 = 1 << 13, ///< 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 = 1 << 14, ///< 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 = 1 << 15, ///< 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 = 1 << 16, ///< When specified during a search and replace operation,
|
|
///< then only the first occurrence of the regular
|
|
///< expression is replaced.
|
|
///<
|
|
format_literal = 1 << 17, ///< Treat the format string as a literal.
|
|
///<
|
|
format_all = 1 << 18 ///< Specifies that all syntax extensions are enabled,
|
|
///< including conditional (?ddexpression1:expression2)
|
|
///< replacements.
|
|
///<
|
|
};
|
|
|
|
/// Error codes used by the regex_error type
|
|
///
|
|
enum error_type
|
|
{
|
|
error_collate, ///< The expression contained an invalid collating element name.
|
|
///<
|
|
error_ctype, ///< The expression contained an invalid character class name.
|
|
///<
|
|
error_escape, ///< The expression contained an invalid escaped character,
|
|
///< or a trailing escape.
|
|
///<
|
|
error_subreg, ///< The expression contained an invalid back-reference.
|
|
///<
|
|
error_brack, ///< The expression contained mismatched [ and ].
|
|
///<
|
|
error_paren, ///< The expression contained mismatched ( and ).
|
|
///<
|
|
error_brace, ///< The expression contained mismatched { and }.
|
|
///<
|
|
error_badbrace, ///< The expression contained an invalid range in a {} expression.
|
|
///<
|
|
error_range, ///< The expression contained an invalid character range, for
|
|
///< example [b-a].
|
|
///<
|
|
error_space, ///< There was insufficient memory to convert the expression into a
|
|
///< finite state machine.
|
|
///<
|
|
error_badrepeat, ///< One of *?+{ was not preceded by a valid regular expression.
|
|
///<
|
|
error_complexity, ///< The complexity of an attempted match against a regular
|
|
///< expression exceeded a pre-set level.
|
|
///<
|
|
error_stack, ///< There was insufficient memory to determine whether the regular
|
|
///< expression could match the specified character sequence.
|
|
///<
|
|
error_badref, ///< An nested regex is uninitialized.
|
|
///<
|
|
error_badmark, ///< An invalid use of a named capture.
|
|
///<
|
|
error_badlookbehind, ///< An attempt to create a variable-width look-behind assertion
|
|
///< was detected.
|
|
///<
|
|
error_badrule, ///< An invalid use of a rule was detected.
|
|
///<
|
|
error_badarg, ///< An argument to an action was unbound.
|
|
///<
|
|
error_badattr, ///< Tried to read from an uninitialized attribute.
|
|
///<
|
|
error_internal ///< An internal error has occurred.
|
|
///<
|
|
};
|
|
|
|
/// INTERNAL ONLY
|
|
inline syntax_option_type operator &(syntax_option_type b1, syntax_option_type b2)
|
|
{
|
|
return static_cast<syntax_option_type>(
|
|
static_cast<int>(b1) & static_cast<int>(b2));
|
|
}
|
|
|
|
/// INTERNAL ONLY
|
|
inline syntax_option_type operator |(syntax_option_type b1, syntax_option_type b2)
|
|
{
|
|
return static_cast<syntax_option_type>(static_cast<int>(b1) | static_cast<int>(b2));
|
|
}
|
|
|
|
/// INTERNAL ONLY
|
|
inline syntax_option_type operator ^(syntax_option_type b1, syntax_option_type b2)
|
|
{
|
|
return static_cast<syntax_option_type>(static_cast<int>(b1) ^ static_cast<int>(b2));
|
|
}
|
|
|
|
/// INTERNAL ONLY
|
|
inline syntax_option_type operator ~(syntax_option_type b)
|
|
{
|
|
return static_cast<syntax_option_type>(~static_cast<int>(b));
|
|
}
|
|
|
|
/// INTERNAL ONLY
|
|
inline match_flag_type operator &(match_flag_type b1, match_flag_type b2)
|
|
{
|
|
return static_cast<match_flag_type>(static_cast<int>(b1) & static_cast<int>(b2));
|
|
}
|
|
|
|
/// INTERNAL ONLY
|
|
inline match_flag_type operator |(match_flag_type b1, match_flag_type b2)
|
|
{
|
|
return static_cast<match_flag_type>(static_cast<int>(b1) | static_cast<int>(b2));
|
|
}
|
|
|
|
/// INTERNAL ONLY
|
|
inline match_flag_type operator ^(match_flag_type b1, match_flag_type b2)
|
|
{
|
|
return static_cast<match_flag_type>(static_cast<int>(b1) ^ static_cast<int>(b2));
|
|
}
|
|
|
|
/// INTERNAL ONLY
|
|
inline match_flag_type operator ~(match_flag_type b)
|
|
{
|
|
return static_cast<match_flag_type>(~static_cast<int>(b));
|
|
}
|
|
|
|
}}} // namespace boost::xpressive::regex_constants
|
|
|
|
#ifndef BOOST_XPRESSIVE_DOXYGEN_INVOKED
|
|
# undef icase
|
|
#endif
|
|
|
|
#endif
|