boost/xpressive/regex_constants.hpp

   1 ///////////////////////////////////////////////////////////////////////////////
   2 /// \file regex_constants.hpp
   3 /// Contains definitions for the syntax_option_type, match_flag_type and
   4 /// error_type enumerations.
   5 //
   6 //  Copyright 2008 Eric Niebler. Distributed under the Boost
   7 //  Software License, Version 1.0. (See accompanying file
   8 //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
   9
  10 #ifndef BOOST_XPRESSIVE_REGEX_CONSTANTS_HPP_EAN_10_04_2005
  11 #define BOOST_XPRESSIVE_REGEX_CONSTANTS_HPP_EAN_10_04_2005
  12
  13 // MS compatible compilers support #pragma once
  14 #if defined(_MSC_VER) && (_MSC_VER >= 1020)
  15 # pragma once
  16 #endif
  17
  18 #include <boost/mpl/identity.hpp>
  19
  20 #ifndef BOOST_XPRESSIVE_DOXYGEN_INVOKED
  21 # define icase icase_
  22 #endif
  23
  24 namespace boost { namespace xpressive { namespace regex_constants
  25 {
  26
  27 /// Flags used to customize the regex syntax
  28 ///
  29 enum syntax_option_type
  30 {
  31     // these flags are required:
  32
  33     ECMAScript  = 0,        ///< Specifies that the grammar recognized by the regular expression
  34                             ///< engine uses its normal semantics: that is the same as that given
  35                             ///< in the ECMA-262, ECMAScript Language Specification, Chapter 15
  36                             ///< part 10, RegExp (Regular Expression) Objects (FWD.1).
  37                             ///<
  38     icase       = 1 << 1,   ///< Specifies that matching of regular expressions against a character
  39                             ///< container sequence shall be performed without regard to case.
  40                             ///<
  41     nosubs      = 1 << 2,   ///< Specifies that when a regular expression is matched against a
  42                             ///< character container sequence, then no sub-expression matches are to
  43                             ///< be stored in the supplied match_results structure.
  44                             ///<
  45     optimize    = 1 << 3,   ///< Specifies that the regular expression engine should pay more
  46                             ///< attention to the speed with which regular expressions are matched,
  47                             ///< and less to the speed with which regular expression objects are
  48                             ///< constructed. Otherwise it has no detectable effect on the program
  49                             ///< output.
  50                             ///<
  51     collate     = 1 << 4,   ///< Specifies that character ranges of the form "[a-b]" should be
  52                             ///< locale sensitive.
  53                             ///<
  54
  55     // These flags are optional. If the functionality is supported
  56     // then the flags shall take these names.
  57
  58     //basic       = 1 << 5,   ///< Specifies that the grammar recognized by the regular expression
  59     //                        ///< engine is the same as that used by POSIX basic regular expressions
  60     //                        ///< in IEEE Std 1003.1-2001, Portable Operating System Interface
  61     //                        ///< (POSIX), Base Definitions and Headers, Section 9, Regular
  62     //                        ///< Expressions (FWD.1).
  63     //                        ///<
  64     //extended    = 1 << 6,   ///< Specifies that the grammar recognized by the regular expression
  65     //                        ///< engine is the same as that used by POSIX extended regular
  66     //                        ///< expressions in IEEE Std 1003.1-2001, Portable Operating System
  67     //                        ///< Interface (POSIX), Base Definitions and Headers, Section 9,
  68     //                        ///< Regular Expressions (FWD.1).
  69     //                        ///<
  70     //awk         = 1 << 7,   ///< Specifies that the grammar recognized by the regular expression
  71     //                        ///< engine is the same as that used by POSIX utility awk in IEEE Std
  72     //                        ///< 1003.1-2001, Portable Operating System Interface (POSIX), Shells
  73     //                        ///< and Utilities, Section 4, awk (FWD.1).
  74     //                        ///<
  75     //grep        = 1 << 8,   ///< Specifies that the grammar recognized by the regular expression
  76     //                        ///< engine is the same as that used by POSIX utility grep in IEEE Std
  77     //                        ///< 1003.1-2001, Portable Operating System Interface (POSIX),
  78     //                        ///< Shells and Utilities, Section 4, Utilities, grep (FWD.1).
  79     //                        ///<
  80     //egrep       = 1 << 9,   ///< Specifies that the grammar recognized by the regular expression
  81     //                        ///< engine is the same as that used by POSIX utility grep when given
  82     //                        ///< the -E option in IEEE Std 1003.1-2001, Portable Operating System
  83     //                        ///< Interface (POSIX), Shells and Utilities, Section 4, Utilities,
  84     //                        ///< grep (FWD.1).
  85     //                        ///<
  86
  87     // these flags are specific to xpressive, and they help with perl compliance.
  88
  89     single_line         = 1 << 10,  ///< Specifies that the ^ and \$ metacharacters DO NOT match at
  90                                     ///< internal line breaks. Note that this is the opposite of the
  91                                     ///< perl default. It is the inverse of perl's /m (multi-line)
  92                                     ///< modifier.
  93                                     ///<
  94     not_dot_null        = 1 << 11,  ///< Specifies that the . metacharacter does not match the null
  95                                     ///< character \\0.
  96                                     ///<
  97     not_dot_newline     = 1 << 12,  ///< Specifies that the . metacharacter does not match the
  98                                     ///< newline character \\n.
  99                                     ///<
 100     ignore_white_space  = 1 << 13   ///< Specifies that non-escaped white-space is not significant.
 101                                     ///<
 102 };
 103
 104 /// Flags used to customize the behavior of the regex algorithms
 105 ///
 106 enum match_flag_type
 107 {
 108     match_default           = 0,        ///< Specifies that matching of regular expressions proceeds
 109                                         ///< without any modification of the normal rules used in
 110                                         ///< ECMA-262, ECMAScript Language Specification, Chapter 15
 111                                         ///< part 10, RegExp (Regular Expression) Objects (FWD.1)
 112                                         ///<
 113     match_not_bol           = 1 << 1,   ///< Specifies that the expression "^" should not be matched
 114                                         ///< against the sub-sequence [first,first).
 115                                         ///<
 116     match_not_eol           = 1 << 2,   ///< Specifies that the expression "\$" should not be
 117                                         ///< matched against the sub-sequence [last,last).
 118                                         ///<
 119     match_not_bow           = 1 << 3,   ///< Specifies that the expression "\\b" should not be
 120                                         ///< matched against the sub-sequence [first,first).
 121                                         ///<
 122     match_not_eow           = 1 << 4,   ///< Specifies that the expression "\\b" should not be
 123                                         ///< matched against the sub-sequence [last,last).
 124                                         ///<
 125     match_any               = 1 << 7,   ///< Specifies that if more than one match is possible then
 126                                         ///< any match is an acceptable result.
 127                                         ///<
 128     match_not_null          = 1 << 8,   ///< Specifies that the expression can not be matched
 129                                         ///< against an empty sequence.
 130                                         ///<
 131     match_continuous        = 1 << 10,  ///< Specifies that the expression must match a sub-sequence
 132                                         ///< that begins at first.
 133                                         ///<
 134     match_partial           = 1 << 11,  ///< Specifies that if no match can be found, then it is
 135                                         ///< acceptable to return a match [from, last) where
 136                                         ///< from != last, if there exists some sequence of characters
 137                                         ///< [from,to) of which [from,last) is a prefix, and which
 138                                         ///< would result in a full match.
 139                                         ///<
 140     match_prev_avail        = 1 << 12,  ///< Specifies that --first is a valid iterator position,
 141                                         ///< when this flag is set then the flags match_not_bol
 142                                         ///< and match_not_bow are ignored by the regular expression
 143                                         ///< algorithms (RE.7) and iterators (RE.8).
 144                                         ///<
 145     format_default          = 0,        ///< Specifies that when a regular expression match is to be
 146                                         ///< replaced by a new string, that the new string is
 147                                         ///< constructed using the rules used by the ECMAScript
 148                                         ///< replace function in ECMA-262, ECMAScript Language
 149                                         ///< Specification, Chapter 15 part 5.4.11
 150                                         ///< String.prototype.replace. (FWD.1). In addition during
 151                                         ///< search and replace operations then all non-overlapping
 152                                         ///< occurrences of the regular expression are located and
 153                                         ///< replaced, and sections of the input that did not match
 154                                         ///< the expression, are copied unchanged to the output
 155                                         ///< string.
 156                                         ///<
 157     format_sed              = 1 << 13,  ///< Specifies that when a regular expression match is to be
 158                                         ///< replaced by a new string, that the new string is
 159                                         ///< constructed using the rules used by the Unix sed
 160                                         ///< utility in IEEE Std 1003.1-2001, Portable Operating
 161                                         ///< SystemInterface (POSIX), Shells and Utilities.
 162                                         ///<
 163     format_perl             = 1 << 14,  ///< Specifies that when a regular expression match is to be
 164                                         ///< replaced by a new string, that the new string is
 165                                         ///< constructed using an implementation defined superset
 166                                         ///< of the rules used by the ECMAScript replace function in
 167                                         ///< ECMA-262, ECMAScript Language Specification, Chapter 15
 168                                         ///< part 5.4.11 String.prototype.replace (FWD.1).
 169                                         ///<
 170     format_no_copy          = 1 << 15,  ///< When specified during a search and replace operation,
 171                                         ///< then sections of the character container sequence being
 172                                         ///< searched that do match the regular expression, are not
 173                                         ///< copied to the output string.
 174                                         ///<
 175     format_first_only       = 1 << 16,  ///< When specified during a search and replace operation,
 176                                         ///< then only the first occurrence of the regular
 177                                         ///< expression is replaced.
 178                                         ///<
 179     format_literal          = 1 << 17,  ///< Treat the format string as a literal.
 180                                         ///<
 181     format_all              = 1 << 18   ///< Specifies that all syntax extensions are enabled,
 182                                         ///< including conditional (?ddexpression1:expression2)
 183                                         ///< replacements.
 184                                         ///<
 185 };
 186
 187 /// Error codes used by the regex_error type
 188 ///
 189 enum error_type
 190 {
 191     error_collate,              ///< The expression contained an invalid collating element name.
 192                                 ///<
 193     error_ctype,                ///< The expression contained an invalid character class name.
 194                                 ///<
 195     error_escape,               ///< The expression contained an invalid escaped character,
 196                                 ///< or a trailing escape.
 197                                 ///<
 198     error_subreg,               ///< The expression contained an invalid back-reference.
 199                                 ///<
 200     error_brack,                ///< The expression contained mismatched [ and ].
 201                                 ///<
 202     error_paren,                ///< The expression contained mismatched ( and ).
 203                                 ///<
 204     error_brace,                ///< The expression contained mismatched { and }.
 205                                 ///<
 206     error_badbrace,             ///< The expression contained an invalid range in a {} expression.
 207                                 ///<
 208     error_range,                ///< The expression contained an invalid character range, for
 209                                 ///< example [b-a].
 210                                 ///<
 211     error_space,                ///< There was insufficient memory to convert the expression into a
 212                                 ///< finite state machine.
 213                                 ///<
 214     error_badrepeat,            ///< One of *?+{ was not preceded by a valid regular expression.
 215                                 ///<
 216     error_complexity,           ///< The complexity of an attempted match against a regular
 217                                 ///< expression exceeded a pre-set level.
 218                                 ///<
 219     error_stack,                ///< There was insufficient memory to determine whether the regular
 220                                 ///< expression could match the specified character sequence.
 221                                 ///<
 222     error_badref,               ///< An nested regex is uninitialized.
 223                                 ///<
 224     error_badmark,              ///< An invalid use of a named capture.
 225                                 ///<
 226     error_badlookbehind,        ///< An attempt to create a variable-width look-behind assertion
 227                                 ///< was detected.
 228                                 ///<
 229     error_badrule,              ///< An invalid use of a rule was detected.
 230                                 ///<
 231     error_badarg,               ///< An argument to an action was unbound.
 232                                 ///<
 233     error_badattr,              ///< Tried to read from an uninitialized attribute.
 234                                 ///<
 235     error_internal              ///< An internal error has occured.
 236                                 ///<
 237 };
 238
 239 /// INTERNAL ONLY
 240 inline syntax_option_type operator &(syntax_option_type b1, syntax_option_type b2)
 241 {
 242     return static_cast<syntax_option_type>(
 243         static_cast<int>(b1) & static_cast<int>(b2));
 244 }
 245
 246 /// INTERNAL ONLY
 247 inline syntax_option_type operator |(syntax_option_type b1, syntax_option_type b2)
 248 {
 249     return static_cast<syntax_option_type>(static_cast<int>(b1) | static_cast<int>(b2));
 250 }
 251
 252 /// INTERNAL ONLY
 253 inline syntax_option_type operator ^(syntax_option_type b1, syntax_option_type b2)
 254 {
 255     return static_cast<syntax_option_type>(static_cast<int>(b1) ^ static_cast<int>(b2));
 256 }
 257
 258 /// INTERNAL ONLY
 259 inline syntax_option_type operator ~(syntax_option_type b)
 260 {
 261     return static_cast<syntax_option_type>(~static_cast<int>(b));
 262 }
 263
 264 /// INTERNAL ONLY
 265 inline match_flag_type operator &(match_flag_type b1, match_flag_type b2)
 266 {
 267     return static_cast<match_flag_type>(static_cast<int>(b1) & static_cast<int>(b2));
 268 }
 269
 270 /// INTERNAL ONLY
 271 inline match_flag_type operator |(match_flag_type b1, match_flag_type b2)
 272 {
 273     return static_cast<match_flag_type>(static_cast<int>(b1) | static_cast<int>(b2));
 274 }
 275
 276 /// INTERNAL ONLY
 277 inline match_flag_type operator ^(match_flag_type b1, match_flag_type b2)
 278 {
 279     return static_cast<match_flag_type>(static_cast<int>(b1) ^ static_cast<int>(b2));
 280 }
 281
 282 /// INTERNAL ONLY
 283 inline match_flag_type operator ~(match_flag_type b)
 284 {
 285     return static_cast<match_flag_type>(~static_cast<int>(b));
 286 }
 287
 288 }}} // namespace boost::xpressive::regex_constants
 289
 290 #ifndef BOOST_XPRESSIVE_DOXYGEN_INVOKED
 291 # undef icase
 292 #endif
 293
 294 #endif