/usr/include/boost/xpressive/regex_constants.hpp is in libboost1.46-dev 1.46.1-7ubuntu3.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 | ///////////////////////////////////////////////////////////////////////////////
/// \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) && (_MSC_VER >= 1020)
# 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 occured.
///<
};
/// 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
|