regex File Reference

#include <algorithm>
#include <iterator>
#include <locale>
#include <string>
#include <stdexcept>
#include <utility>
#include <vector>
#include <ctype.h>
#include <wchar.h>
#include <limits.h>
#include <stdlib.h>
#include <string.h>

Classes
class	regex_traits< _Elem >
struct	_Cl_names< _Elem >
struct	_Cmp_cs< _RxTraits >
struct	_Cmp_icase< _RxTraits >
struct	_Cmp_collate< _RxTraits >
struct	_Regex_traits_base
class	_Regex_traits< _Elem >
class	regex_traits< char >
class	regex_traits< wchar_t >
class	regex_error
class	sub_match< _BidIt >
class	match_results< _BidIt, _Alloc >
class	match_results< _BidIt, _Alloc >
struct	_Buf< _Elem >
struct	_Bitmap
struct	_Sequence< _Elem >
class	_Node_base
class	_Root_node
class	_Node_end_group
class	_Node_assert
class	_Node_capture
class	_Node_back
class	_Node_str< _Elem >
class	_Node_class< _Elem, _RxTraits >
class	_Node_endif
class	_Node_if
class	_Node_end_rep
struct	_Loop_vals_t
class	_Node_rep
class	_Builder< _FwdIt, _Elem, _RxTraits >
class	_Bt_state_t< _BidIt >
class	_Tgt_state_t< _BidIt >
struct	_Tgt_state_t< _BidIt >::_Grp_t
class	_Matcher< _BidIt, _Elem, _RxTraits, _It >
class	_Parser< _FwdIt, _Elem, _RxTraits >
class	_Regex_base
class	basic_regex< _Elem, _RxTraits >
class	regex_iterator< _BidIt, _Elem, _RxTraits >
class	regex_token_iterator< _BidIt, _Elem, _RxTraits >

Namespaces
	regex_constants
	tr1
	tr1::regex_constants

Macros
#define	_REGEX_
#define	_REGEX_MAX_COMPLEXITY_COUNT   10000000L /* set to 0 to disable */
#define	_REGEX_MAX_STACK_COUNT   1000L /* set to 0 to disable */
#define	_ENHANCED_REGEX_VISUALIZER   0
#define	_REGEX_DIFFT(iter)   typename iterator_traits<iter>::difference_type
#define	_REGEX_VALT(iter)   typename iterator_traits<iter>::value_type
#define	_REGEX_BITMASK_OPS(Ty)
#define	_REGEX_CHAR_CLASS_NAME(n, c)   { n, sizeof (n)/sizeof (n[0]) - 1, c }
#define	_Isdigit(x)   ('0' <= (x) && (x) <= '9')

Typedefs
typedef sub_match< const char * >	csub_match
typedef sub_match< const wchar_t * >	wcsub_match
typedef sub_match< string::const_iterator >	ssub_match
typedef sub_match< wstring::const_iterator >	wssub_match
typedef basic_regex< char >	regex
typedef basic_regex< wchar_t >	wregex
typedef match_results< const char * >	cmatch
typedef match_results< const wchar_t * >	wcmatch
typedef match_results< string::const_iterator >	smatch
typedef match_results< wstring::const_iterator >	wsmatch
typedef regex_iterator< const char * >	cregex_iterator
typedef regex_iterator< const wchar_t * >	wcregex_iterator
typedef regex_iterator< string::const_iterator >	sregex_iterator
typedef regex_iterator< wstring::const_iterator >	wsregex_iterator
typedef regex_token_iterator< const char * >	cregex_token_iterator
typedef regex_token_iterator< const wchar_t * >	wcregex_token_iterator
typedef regex_token_iterator< string::const_iterator >	sregex_token_iterator
typedef regex_token_iterator< wstring::const_iterator >	wsregex_token_iterator

Enumerations
enum	_Meta_type {   _Meta_lpar = '(', _Meta_rpar = ')', _Meta_dlr = '$', _Meta_caret = '^',   _Meta_dot = '.', _Meta_star = '*', _Meta_plus = '+', _Meta_query = '?',   _Meta_lsq = '[', _Meta_rsq = ']', _Meta_bar = '|', _Meta_esc = '\\',   _Meta_dash = '-', _Meta_lbr = '{', _Meta_rbr = '}', _Meta_comma = ',',   _Meta_colon = ':', _Meta_equal = '=', _Meta_exc = '!', _Meta_eos = -1,   _Meta_nl = '\n', _Meta_cr = '\r', _Meta_bsp = '\b', _Meta_chr = 0,   _Esc_bsl = '\\', _Esc_word = 'b', _Esc_not_word = 'B', _Esc_ctrl_a = 'a',   _Esc_ctrl_b = 'b', _Esc_ctrl_f = 'f', _Esc_ctrl_n = 'n', _Esc_ctrl_r = 'r',   _Esc_ctrl_t = 't', _Esc_ctrl_v = 'v', _Esc_ctrl = 'c', _Esc_hex = 'x',   _Esc_uni = 'u' }
enum	regex_constants::syntax_option_type {   regex_constants::ECMAScript = 0x01, regex_constants::basic = 0x02, regex_constants::extended = 0x04, regex_constants::awk = 0x08,   regex_constants::grep = 0x10, regex_constants::egrep = 0x20, regex_constants::_Gmask = 0x3F, regex_constants::icase = 0x0100,   regex_constants::nosubs = 0x0200, regex_constants::optimize = 0x0400, regex_constants::collate = 0x0800 }
enum	regex_constants::match_flag_type {   regex_constants::match_default = 0x0000, regex_constants::match_not_bol = 0x0001, regex_constants::match_not_eol = 0x0002, regex_constants::match_not_bow = 0x0004,   regex_constants::match_not_eow = 0x0008, regex_constants::match_any = 0x0010, regex_constants::match_not_null = 0x0020, regex_constants::match_continuous = 0x0040,   regex_constants::_Match_partial = 0x0080, regex_constants::match_prev_avail = 0x0100, regex_constants::format_default = 0x0000, regex_constants::format_sed = 0x0400,   regex_constants::format_no_copy = 0x0800, regex_constants::format_first_only = 0x1000, regex_constants::_Match_not_null = 0x2000 }
enum	regex_constants::error_type {   regex_constants::error_collate, regex_constants::error_ctype, regex_constants::error_escape, regex_constants::error_backref,   regex_constants::error_brack, regex_constants::error_paren, regex_constants::error_brace, regex_constants::error_badbrace,   regex_constants::error_range, regex_constants::error_space, regex_constants::error_badrepeat, regex_constants::error_complexity,   regex_constants::error_stack, regex_constants::error_parse, regex_constants::error_syntax }
enum	_Node_flags {   _Fl_none = 0x00, _Fl_negate = 0x01, _Fl_greedy = 0x02, _Fl_final = 0x04,   _Fl_longest = 0x08 }
enum	_Node_type {   _N_none, _N_nop, _N_bol, _N_eol,   _N_wbound, _N_dot, _N_str, _N_class,   _N_group, _N_end_group, _N_assert, _N_neg_assert,   _N_end_assert, _N_capture, _N_end_capture, _N_back,   _N_if, _N_endif, _N_rep, _N_end_rep,   _N_begin, _N_end }
enum	_Prs_ret { _Prs_none, _Prs_chr, _Prs_set }
enum	_Lang_flags {   _L_ext_rep = 0x00000001, _L_alt_pipe = 0x00000002, _L_alt_nl = 0x00000004, _L_nex_grp = 0x00000008,   _L_nex_rep = 0x00000010, _L_nc_grp = 0x00000020, _L_asrt_gen = 0x00000040, _L_asrt_wrd = 0x00000080,   _L_bckr = 0x00000100, _L_lim_bckr = 0x00000200, _L_ngr_rep = 0x00000400, _L_esc_uni = 0x00000800,   _L_esc_hex = 0x00001000, _L_esc_oct = 0x00002000, _L_esc_bsl = 0x00004000, _L_esc_ffnx = 0x00008000,   _L_esc_ffn = 0x00010000, _L_esc_wsd = 0x00020000, _L_esc_ctrl = 0x00040000, _L_no_nl = 0x00080000,   _L_bzr_chr = 0x00100000, _L_grp_esc = 0x00200000, _L_ident_ECMA = 0x00400000, _L_ident_ERE = 0x00800000,   _L_ident_awk = 0x01000000, _L_anch_rstr = 0x02000000, _L_star_beg = 0x04000000, _L_empty_grp = 0x08000000,   _L_paren_bal = 0x10000000, _L_brk_rstr = 0x20000000, _L_mtch_long = 0x40000000, _L_no_subs = 0x80000000 }

Functions
_CRTIMP2_PURE	_NO_RETURN (__CLRCALL_PURE_OR_CDECL _Xregex_error(regex_constants::error_type _Code))
template<class _InIt1 , class _InIt2 , class _Pr >
bool	_Same (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _Pr _Pred)
template<class _BidIt >
bool	operator== (const sub_match< _BidIt > &_Left, const sub_match< _BidIt > &_Right)
template<class _BidIt >
bool	operator!= (const sub_match< _BidIt > &_Left, const sub_match< _BidIt > &_Right)
template<class _BidIt >
bool	operator< (const sub_match< _BidIt > &_Left, const sub_match< _BidIt > &_Right)
template<class _BidIt >
bool	operator> (const sub_match< _BidIt > &_Left, const sub_match< _BidIt > &_Right)
template<class _BidIt >
bool	operator<= (const sub_match< _BidIt > &_Left, const sub_match< _BidIt > &_Right)
template<class _BidIt >
bool	operator>= (const sub_match< _BidIt > &_Left, const sub_match< _BidIt > &_Right)
template<class _BidIt >
bool	operator== (const _REGEX_VALT(_BidIt)*_Left, const sub_match< _BidIt > &_Right)
template<class _BidIt >
bool	operator!= (const _REGEX_VALT(_BidIt)*_Left, const sub_match< _BidIt > &_Right)
template<class _BidIt >
bool	operator< (const _REGEX_VALT(_BidIt)*_Left, const sub_match< _BidIt > &_Right)
template<class _BidIt >
bool	operator> (const _REGEX_VALT(_BidIt)*_Left, const sub_match< _BidIt > &_Right)
template<class _BidIt >
bool	operator<= (const _REGEX_VALT(_BidIt)*_Left, const sub_match< _BidIt > &_Right)
template<class _BidIt >
bool	operator>= (const _REGEX_VALT(_BidIt)*_Left, const sub_match< _BidIt > &_Right)
template<class _BidIt >
bool	operator== (const sub_match< _BidIt > &_Left, const _REGEX_VALT(_BidIt)*_Right)
template<class _BidIt >
bool	operator!= (const sub_match< _BidIt > &_Left, const _REGEX_VALT(_BidIt)*_Right)
template<class _BidIt >
bool	operator< (const sub_match< _BidIt > &_Left, const _REGEX_VALT(_BidIt)*_Right)
template<class _BidIt >
bool	operator> (const sub_match< _BidIt > &_Left, const _REGEX_VALT(_BidIt)*_Right)
template<class _BidIt >
bool	operator<= (const sub_match< _BidIt > &_Left, const _REGEX_VALT(_BidIt)*_Right)
template<class _BidIt >
bool	operator>= (const sub_match< _BidIt > &_Left, const _REGEX_VALT(_BidIt)*_Right)
template<class _BidIt >
bool	operator== (const _REGEX_VALT(_BidIt)&_Left, const sub_match< _BidIt > &_Right)
template<class _BidIt >
bool	operator!= (const _REGEX_VALT(_BidIt)&_Left, const sub_match< _BidIt > &_Right)
template<class _BidIt >
bool	operator< (const _REGEX_VALT(_BidIt)&_Left, const sub_match< _BidIt > &_Right)
template<class _BidIt >
bool	operator> (const _REGEX_VALT(_BidIt)&_Left, const sub_match< _BidIt > &_Right)
template<class _BidIt >
bool	operator<= (const _REGEX_VALT(_BidIt)&_Left, const sub_match< _BidIt > &_Right)
template<class _BidIt >
bool	operator>= (const _REGEX_VALT(_BidIt)&_Left, const sub_match< _BidIt > &_Right)
template<class _BidIt >
bool	operator== (const sub_match< _BidIt > &_Left, const _REGEX_VALT(_BidIt)&_Right)
template<class _BidIt >
bool	operator!= (const sub_match< _BidIt > &_Left, const _REGEX_VALT(_BidIt)&_Right)
template<class _BidIt >
bool	operator< (const sub_match< _BidIt > &_Left, const _REGEX_VALT(_BidIt)&_Right)
template<class _BidIt >
bool	operator> (const sub_match< _BidIt > &_Left, const _REGEX_VALT(_BidIt)&_Right)
template<class _BidIt >
bool	operator<= (const sub_match< _BidIt > &_Left, const _REGEX_VALT(_BidIt)&_Right)
template<class _BidIt >
bool	operator>= (const sub_match< _BidIt > &_Left, const _REGEX_VALT(_BidIt)&_Right)
template<class _BidIt , class _Traits , class _Alloc >
bool	operator== (const sub_match< _BidIt > &_Left, const basic_string< _REGEX_VALT(_BidIt), _Traits, _Alloc > &_Right)
template<class _BidIt , class _Traits , class _Alloc >
bool	operator!= (const sub_match< _BidIt > &_Left, const basic_string< _REGEX_VALT(_BidIt), _Traits, _Alloc > &_Right)
template<class _BidIt , class _Traits , class _Alloc >
bool	operator< (const sub_match< _BidIt > &_Left, const basic_string< _REGEX_VALT(_BidIt), _Traits, _Alloc > &_Right)
template<class _BidIt , class _Traits , class _Alloc >
bool	operator> (const sub_match< _BidIt > &_Left, const basic_string< _REGEX_VALT(_BidIt), _Traits, _Alloc > &_Right)
template<class _BidIt , class _Traits , class _Alloc >
bool	operator<= (const sub_match< _BidIt > &_Left, const basic_string< _REGEX_VALT(_BidIt), _Traits, _Alloc > &_Right)
template<class _BidIt , class _Traits , class _Alloc >
bool	operator>= (const sub_match< _BidIt > &_Left, const basic_string< _REGEX_VALT(_BidIt), _Traits, _Alloc > &_Right)
template<class _BidIt , class _Traits , class _Alloc >
bool	operator== (const basic_string< _REGEX_VALT(_BidIt), _Traits, _Alloc > &_Left, const sub_match< _BidIt > &_Right)
template<class _BidIt , class _Traits , class _Alloc >
bool	operator!= (const basic_string< _REGEX_VALT(_BidIt), _Traits, _Alloc > &_Left, const sub_match< _BidIt > &_Right)
template<class _BidIt , class _Traits , class _Alloc >
bool	operator< (const basic_string< _REGEX_VALT(_BidIt), _Traits, _Alloc > &_Left, const sub_match< _BidIt > &_Right)
template<class _BidIt , class _Traits , class _Alloc >
bool	operator> (const basic_string< _REGEX_VALT(_BidIt), _Traits, _Alloc > &_Left, const sub_match< _BidIt > &_Right)
template<class _BidIt , class _Traits , class _Alloc >
bool	operator<= (const basic_string< _REGEX_VALT(_BidIt), _Traits, _Alloc > &_Left, const sub_match< _BidIt > &_Right)
template<class _BidIt , class _Traits , class _Alloc >
bool	operator>= (const basic_string< _REGEX_VALT(_BidIt), _Traits, _Alloc > &_Left, const sub_match< _BidIt > &_Right)
template<class _Elem , class _Traits , class _BidIt >
basic_ostream< _Elem, _Traits > &	operator<< (basic_ostream< _Elem, _Traits > &_Ostr, const sub_match< _BidIt > &_Match)
template<class _BidIt , class _Alloc , class _InIt , class _OutIt >
_OutIt	_Format_default (const match_results< _BidIt, _Alloc > &_Match, _OutIt _Out, _InIt _First, _InIt _Last, regex_constants::match_flag_type _Flags=regex_constants::format_default)
template<class _BidIt , class _Alloc , class _InIt , class _OutIt >
_OutIt	_Format_sed (const match_results< _BidIt, _Alloc > &_Match, _OutIt _Out, _InIt _First, _InIt _Last, regex_constants::match_flag_type _Flags=regex_constants::format_default)
template<class _BidIt , class _Alloc >
bool	operator== (const match_results< _BidIt, _Alloc > &_Left, const match_results< _BidIt, _Alloc > &_Right)
template<class _BidIt , class _Alloc >
bool	operator!= (const match_results< _BidIt, _Alloc > &_Left, const match_results< _BidIt, _Alloc > &_Right)
_Node_flags	operator| (_Node_flags _Left, _Node_flags _Right)
_Node_flags	operator|= (_Node_flags &_Left, _Node_flags _Right)
_Node_flags	operator^= (_Node_flags &_Left, _Node_flags _Right)
void	_Destroy_node (_Node_base *_Nx, _Node_base *_Ne=0)
template<class _Elem , class _RxTraits >
void	swap (basic_regex< _Elem, _RxTraits > &_Left, basic_regex< _Elem, _RxTraits > &_Right) _THROW0()
template<class _BidIt , class _Alloc >
void	swap (match_results< _BidIt, _Alloc > &_Left, match_results< _BidIt, _Alloc > &_Right) _THROW0()
template<class _BidIt , class _Alloc , class _Elem , class _RxTraits , class _It >
bool	_Regex_match (_It _First, _It _Last, match_results< _BidIt, _Alloc > *_Matches, const basic_regex< _Elem, _RxTraits > &_Re, regex_constants::match_flag_type _Flgs, bool _Full)
template<class _BidIt , class _Alloc , class _Elem , class _RxTraits >
bool	regex_match (_BidIt _First, _BidIt _Last, match_results< _BidIt, _Alloc > &_Matches, const basic_regex< _Elem, _RxTraits > &_Re, regex_constants::match_flag_type _Flgs=regex_constants::match_default)
template<class _BidIt , class _Elem , class _RxTraits >
bool	regex_match (_BidIt _First, _BidIt _Last, const basic_regex< _Elem, _RxTraits > &_Re, regex_constants::match_flag_type _Flgs=regex_constants::match_default)
template<class _Elem , class _RxTraits >
bool	regex_match (_In_z_ const _Elem *_Str, const basic_regex< _Elem, _RxTraits > &_Re, regex_constants::match_flag_type _Flgs=regex_constants::match_default)
template<class _Elem , class _Alloc , class _RxTraits >
bool	regex_match (_In_z_ const _Elem *_Str, match_results< const _Elem *, _Alloc > &_Matches, const basic_regex< _Elem, _RxTraits > &_Re, regex_constants::match_flag_type _Flgs=regex_constants::match_default)
template<class _StTraits , class _StAlloc , class _Alloc , class _Elem , class _RxTraits >
bool	regex_match (const basic_string< _Elem, _StTraits, _StAlloc > &_Str, match_results< typename basic_string< _Elem, _StTraits, _StAlloc >::const_iterator, _Alloc > &_Matches, const basic_regex< _Elem, _RxTraits > &_Re, regex_constants::match_flag_type _Flgs=regex_constants::match_default)
template<class _StTraits , class _StAlloc , class _Elem , class _RxTraits >
bool	regex_match (const basic_string< _Elem, _StTraits, _StAlloc > &_Str, const basic_regex< _Elem, _RxTraits > &_Re, regex_constants::match_flag_type _Flgs=regex_constants::match_default)
template<class _BidIt , class _Alloc , class _Elem , class _RxTraits , class _It >
bool	_Regex_search (_It _First, _It _Last, match_results< _BidIt, _Alloc > *_Matches, const basic_regex< _Elem, _RxTraits > &_Re, regex_constants::match_flag_type _Flgs, _It _Org)
template<class _BidIt , class _Alloc , class _Elem , class _RxTraits >
bool	regex_search (_BidIt _First, _BidIt _Last, match_results< _BidIt, _Alloc > &_Matches, const basic_regex< _Elem, _RxTraits > &_Re, regex_constants::match_flag_type _Flgs=regex_constants::match_default)
template<class _BidIt , class _Elem , class _RxTraits >
bool	regex_search (_BidIt _First, _BidIt _Last, const basic_regex< _Elem, _RxTraits > &_Re, regex_constants::match_flag_type _Flgs=regex_constants::match_default)
template<class _Elem , class _RxTraits >
bool	regex_search (_In_z_ const _Elem *_Str, const basic_regex< _Elem, _RxTraits > &_Re, regex_constants::match_flag_type _Flgs=regex_constants::match_default)
template<class _Elem , class _Alloc , class _RxTraits >
bool	regex_search (_In_z_ const _Elem *_Str, match_results< const _Elem *, _Alloc > &_Matches, const basic_regex< _Elem, _RxTraits > &_Re, regex_constants::match_flag_type _Flgs=regex_constants::match_default)
template<class _StTraits , class _StAlloc , class _Alloc , class _Elem , class _RxTraits >
bool	regex_search (const basic_string< _Elem, _StTraits, _StAlloc > &_Str, match_results< typename basic_string< _Elem, _StTraits, _StAlloc >::const_iterator, _Alloc > &_Matches, const basic_regex< _Elem, _RxTraits > &_Re, regex_constants::match_flag_type _Flgs=regex_constants::match_default)
template<class _StTraits , class _StAlloc , class _Elem , class _RxTraits >
bool	regex_search (const basic_string< _Elem, _StTraits, _StAlloc > &_Str, const basic_regex< _Elem, _RxTraits > &_Re, regex_constants::match_flag_type _Flgs=regex_constants::match_default)
template<class _OutIt , class _BidIt , class _RxTraits , class _Elem , class _Traits , class _Alloc >
_OutIt	_Regex_replace (_OutIt _Result, _BidIt _First, _BidIt _Last, const basic_regex< _Elem, _RxTraits > &_Re, const basic_string< _Elem, _Traits, _Alloc > &_Fmt, regex_constants::match_flag_type _Flgs)
template<class _OutIt , class _BidIt , class _RxTraits , class _Elem , class _Traits , class _Alloc >
_OutIt	regex_replace (_OutIt _Result, _BidIt _First, _BidIt _Last, const basic_regex< _Elem, _RxTraits > &_Re, const basic_string< _Elem, _Traits, _Alloc > &_Fmt, regex_constants::match_flag_type _Flgs=regex_constants::match_default)
template<class _OutIt , class _BidIt , class _RxTraits , class _Elem >
_OutIt	regex_replace (_OutIt _Result, _BidIt _First, _BidIt _Last, const basic_regex< _Elem, _RxTraits > &_Re, const _Elem *_Ptr, regex_constants::match_flag_type _Flgs=regex_constants::match_default)
template<class _RxTraits , class _Elem , class _Traits1 , class _Alloc1 , class _Traits2 , class _Alloc2 >
basic_string< _Elem, _Traits1, _Alloc1 >	regex_replace (const basic_string< _Elem, _Traits1, _Alloc1 > &_Str, const basic_regex< _Elem, _RxTraits > &_Re, const basic_string< _Elem, _Traits2, _Alloc2 > &_Fmt, regex_constants::match_flag_type _Flgs=regex_constants::match_default)
template<class _RxTraits , class _Elem , class _Traits1 , class _Alloc1 >
basic_string< _Elem, _Traits1, _Alloc1 >	regex_replace (const basic_string< _Elem, _Traits1, _Alloc1 > &_Str, const basic_regex< _Elem, _RxTraits > &_Re, const _Elem *_Ptr, regex_constants::match_flag_type _Flgs=regex_constants::match_default)
template<class _RxTraits , class _Elem , class _Traits2 , class _Alloc2 >
basic_string< _Elem >	regex_replace (const _Elem *_Pstr, const basic_regex< _Elem, _RxTraits > &_Re, const basic_string< _Elem, _Traits2, _Alloc2 > &_Fmt, regex_constants::match_flag_type _Flgs=regex_constants::match_default)
template<class _RxTraits , class _Elem >
basic_string< _Elem >	regex_replace (const _Elem *_Pstr, const basic_regex< _Elem, _RxTraits > &_Re, const _Elem *_Ptr, regex_constants::match_flag_type _Flgs=regex_constants::match_default)
template<class _BidIt1 , class _BidIt2 , class _Pr >
_BidIt1	_Cmp_chrange (_BidIt1 _Begin1, _BidIt1 _End1, _BidIt2 _Begin2, _BidIt2 _End2, _Pr _Pred, bool _Partial)
template<class _BidIt1 , class _BidIt2 , class _RxTraits >
_BidIt1	_Compare (_BidIt1 _Begin1, _BidIt1 _End1, _BidIt2 _Begin2, _BidIt2 _End2, const _RxTraits &_Traits, regex_constants::syntax_option_type _Sflags, bool _Partial)
template<class _Elem >
bool	_Lookup_range (_Elem _Ch, const _Buf< _Elem > *_Bufptr)
template<class _Elem , class _RxTraits >
bool	_Lookup_equiv (_Elem _Ch, const _Sequence< _Elem > *_Eq, const _RxTraits &_Traits)
template<class _BidIt , class _Elem >
_BidIt	_Lookup_coll (_BidIt _First, _BidIt _Last, const _Sequence< _Elem > *_Eq)

Variables
const int	_BRE_MAX_GRP = 9
const int	_Bmp_max = 256
const int	_Bmp_shift = 3
const int	_Bmp_chrs = 1 << _Bmp_shift
const int	_Bmp_mask = _Bmp_chrs - 1
const int	_Bmp_size = (_Bmp_max + _Bmp_chrs - 1) / _Bmp_chrs
const int	_Buf_incr = 16
const int	_ARRAY_THRESHOLD = 4
static const unsigned int	_ECMA_flags
static const unsigned int	_Basic_flags
static const unsigned int	_Grep_flags
static const unsigned int	_Extended_flags
static const unsigned int	_Awk_flags
static const unsigned int	_Egrep_flags
static const char	_Meta_map []

Macro Definition Documentation

#define _ENHANCED_REGEX_VISUALIZER   0

#define _Isdigit

(

x

)

('0' <= (x) && (x) <= '9')

#define _REGEX_

#define _REGEX_BITMASK_OPS

(

Ty

)

#define _REGEX_CHAR_CLASS_NAME	(		n,
			c
	)		{ n, sizeof (n)/sizeof (n[0]) - 1, c }

#define _REGEX_DIFFT

(

iter

)

typename iterator_traits<iter>::difference_type

#define _REGEX_MAX_COMPLEXITY_COUNT   10000000L /* set to 0 to disable */

#define _REGEX_MAX_STACK_COUNT   1000L /* set to 0 to disable */

#define _REGEX_VALT

(

iter

)

typename iterator_traits<iter>::value_type

Typedef Documentation

typedef match_results<const char *> cmatch

typedef regex_iterator<const char *> cregex_iterator

typedef regex_token_iterator<const char *> cregex_token_iterator

typedef sub_match<const char *> csub_match

typedef basic_regex<char> regex

typedef match_results<string::const_iterator> smatch

typedef regex_iterator<string::const_iterator> sregex_iterator

typedef regex_token_iterator<string::const_iterator> sregex_token_iterator

typedef sub_match<string::const_iterator> ssub_match

typedef match_results<const wchar_t *> wcmatch

typedef regex_iterator<const wchar_t *> wcregex_iterator

typedef regex_token_iterator<const wchar_t *> wcregex_token_iterator

typedef sub_match<const wchar_t *> wcsub_match

typedef basic_regex<wchar_t> wregex

typedef match_results<wstring::const_iterator> wsmatch

typedef regex_iterator<wstring::const_iterator> wsregex_iterator

typedef regex_token_iterator<wstring::const_iterator> wsregex_token_iterator

typedef sub_match<wstring::const_iterator> wssub_match

Enumeration Type Documentation

enum _Lang_flags

Enumerator
_L_ext_rep
_L_alt_pipe
_L_alt_nl
_L_nex_grp
_L_nex_rep
_L_nc_grp
_L_asrt_gen
_L_asrt_wrd
_L_bckr
_L_lim_bckr
_L_ngr_rep
_L_esc_uni
_L_esc_hex
_L_esc_oct
_L_esc_bsl
_L_esc_ffnx
_L_esc_ffn
_L_esc_wsd
_L_esc_ctrl
_L_no_nl
_L_bzr_chr
_L_grp_esc
_L_ident_ECMA
_L_ident_ERE
_L_ident_awk
_L_anch_rstr
_L_star_beg
_L_empty_grp
_L_paren_bal
_L_brk_rstr
_L_mtch_long
_L_no_subs

    {   // describe language properties
    _L_ext_rep = 0x00000001,    // + and ? repetitions
    _L_alt_pipe = 0x00000002,   // uses '|' for alternation
    _L_alt_nl = 0x00000004,     // uses '\n' for alternation (grep, egrep)
    _L_nex_grp = 0x00000008,    // has non-escaped capture groups
    _L_nex_rep = 0x00000010,    // has non-escaped repeats
    _L_nc_grp = 0x00000020,     // has non-capture groups (?:xxx)
    _L_asrt_gen = 0x00000040,   // has generalized assertions (?=xxx), (?!xxx)
    _L_asrt_wrd = 0x00000080,   // has word boundary assertions (\b, \B)
    _L_bckr = 0x00000100,       // has backreferences (ERE doesn't)
    _L_lim_bckr = 0x00000200,   // has limited backreferences (BRE \1-\9)
    _L_ngr_rep = 0x00000400,    // has non-greedy repeats
    _L_esc_uni = 0x00000800,    // has Unicode escape sequences
    _L_esc_hex = 0x00001000,    // has hexadecimal escape sequences
    _L_esc_oct = 0x00002000,    // has octal escape sequences
    _L_esc_bsl = 0x00004000,    // has escape backslash in character classes
    _L_esc_ffnx = 0x00008000,   // has extra file escape (\a)
    _L_esc_ffn = 0x00010000,    // has limited file escapes (\[bfnrtv])
    _L_esc_wsd = 0x00020000,    // has w, s, and d character set escapes
    _L_esc_ctrl = 0x00040000,   // has control escape
    _L_no_nl = 0x00080000,      // no newline in pattern or matching text
    _L_bzr_chr = 0x00100000,    // \0 is a valid character constant
    _L_grp_esc = 0x00200000,    // \ is special character in group
    _L_ident_ECMA = 0x00400000, // ECMA identity escape (not identifierpart)
    _L_ident_ERE = 0x00800000,  // ERE identity escape (.[\*^$, plus {+?}()
    _L_ident_awk = 0x01000000,  // awk identity escape ( ERE plus "/)
    _L_anch_rstr = 0x02000000,  // anchor restricted to beginning/end
    _L_star_beg = 0x04000000,   // star okay at beginning of RE/expr (BRE)
    _L_empty_grp = 0x08000000,  // empty group allowed (ERE prohibits "()")
    _L_paren_bal = 0x10000000,  // ')'/'}'/']' special only after '('/'{'/']'
    _L_brk_rstr = 0x20000000,   // ']' not special when first character in set
    _L_mtch_long = 0x40000000,  // find longest match (ERE, BRE)
    _L_no_subs = 0x80000000     // subexpression matches not recorded
    };

enum _Meta_type

Enumerator
_Meta_lpar
_Meta_rpar
_Meta_dlr
_Meta_caret
_Meta_dot
_Meta_star
_Meta_plus
_Meta_query
_Meta_lsq
_Meta_rsq
_Meta_bar
_Meta_esc
_Meta_dash
_Meta_lbr
_Meta_rbr
_Meta_comma
_Meta_colon
_Meta_equal
_Meta_exc
_Meta_eos
_Meta_nl
_Meta_cr
_Meta_bsp
_Meta_chr
_Esc_bsl
_Esc_word
_Esc_not_word
_Esc_ctrl_a
_Esc_ctrl_b
_Esc_ctrl_f
_Esc_ctrl_n
_Esc_ctrl_r
_Esc_ctrl_t
_Esc_ctrl_v
_Esc_ctrl
_Esc_hex
_Esc_uni

    {   // meta character representations for parser
    _Meta_lpar = '(',
    _Meta_rpar = ')',
    _Meta_dlr = '$',
    _Meta_caret = '^',
    _Meta_dot = '.',
    _Meta_star = '*',
    _Meta_plus = '+',
    _Meta_query = '?',
    _Meta_lsq = '[',
    _Meta_rsq = ']',
    _Meta_bar = '|',
    _Meta_esc = '\\',
    _Meta_dash = '-',
    _Meta_lbr = '{',
    _Meta_rbr = '}',
    _Meta_comma = ',',
    _Meta_colon = ':',
    _Meta_equal = '=',
    _Meta_exc = '!',
    _Meta_eos = -1,
    _Meta_nl = '\n',
    _Meta_cr = '\r',
    _Meta_bsp = '\b',
    _Meta_chr = 0,

    _Esc_bsl = '\\',
    _Esc_word = 'b',
    _Esc_not_word = 'B',
    _Esc_ctrl_a = 'a',
    _Esc_ctrl_b = 'b',
    _Esc_ctrl_f = 'f',
    _Esc_ctrl_n = 'n',
    _Esc_ctrl_r = 'r',
    _Esc_ctrl_t = 't',
    _Esc_ctrl_v = 'v',
    _Esc_ctrl = 'c',
    _Esc_hex = 'x',
    _Esc_uni = 'u'
    };

enum _Node_flags

Enumerator
_Fl_none
_Fl_negate
_Fl_greedy
_Fl_final
_Fl_longest

    {   // flags for nfa nodes with special properties
    _Fl_none = 0x00,
    _Fl_negate = 0x01,
    _Fl_greedy = 0x02,
    _Fl_final = 0x04,
    _Fl_longest = 0x08
    };

enum _Node_type

Enumerator
_N_none
_N_nop
_N_bol
_N_eol
_N_wbound
_N_dot
_N_str
_N_class
_N_group
_N_end_group
_N_assert
_N_neg_assert
_N_end_assert
_N_capture
_N_end_capture
_N_back
_N_if
_N_endif
_N_rep
_N_end_rep
_N_begin
_N_end

    {   // type flag for nfa nodes
    _N_none,
    _N_nop,
    _N_bol,
    _N_eol,
    _N_wbound,
    _N_dot,
    _N_str,
    _N_class,
    _N_group,
    _N_end_group,
    _N_assert,
    _N_neg_assert,
    _N_end_assert,
    _N_capture,
    _N_end_capture,
    _N_back,
    _N_if,
    _N_endif,
    _N_rep,
    _N_end_rep,
    _N_begin,
    _N_end
    };

enum _Prs_ret

Enumerator
_Prs_none
_Prs_chr
_Prs_set

    {   // indicate class element type
    _Prs_none,
    _Prs_chr,
    _Prs_set
    };

Function Documentation

template<class _BidIt1 , class _BidIt2 , class _Pr >

_BidIt1 _Cmp_chrange ( _BidIt1  _Begin1, _BidIt1  _End1, _BidIt2  _Begin2, _BidIt2  _End2, _Pr  _Pred, bool  _Partial  )

inline

    {   // compare character ranges
    _BidIt1 _Res = _Begin1;
    while (_Begin1 != _End1 && _Begin2 != _End2)
        if (!_Pred(*_Begin1++, *_Begin2++))
            return (_Res);
    return (_Begin2 == _End2 ? _Begin1
        : _Partial && _Begin1 == _End1 ? _Begin1
        : _Res);
    }

template<class _BidIt1 , class _BidIt2 , class _RxTraits >

_BidIt1 _Compare ( _BidIt1  _Begin1, _BidIt1  _End1, _BidIt2  _Begin2, _BidIt2  _End2, const _RxTraits &  _Traits, regex_constants::syntax_option_type  _Sflags, bool  _Partial  )

inline

    {   // compare character ranges
    _BidIt1 _Res = _End1;
    if (_Sflags & regex_constants::icase)
        _Res = _Cmp_chrange(_Begin1, _End1, _Begin2, _End2,
            _Cmp_icase<_RxTraits>(_Traits), _Partial);
    else if (_Sflags & regex_constants::collate)
        _Res = _Cmp_chrange(_Begin1, _End1, _Begin2, _End2,
            _Cmp_collate<_RxTraits>(_Traits), _Partial);
    else
        _Res = _Cmp_chrange(_Begin1, _End1, _Begin2, _End2,
            _Cmp_cs<_RxTraits>(), _Partial);
    return (_Res);
    }

void _Destroy_node ( _Node_base *  _Nx, _Node_base *  _Ne = 0  )

inline

    {   // destroy sublist of nodes
    while (_Nx != _Ne && _Nx != 0)
        {   // destroy node
        _Node_base *_Tmp = _Nx;
        _Nx = _Nx->_Next;
        _Tmp->_Next = 0;
        delete _Tmp;
        }
    }

template<class _BidIt , class _Alloc , class _InIt , class _OutIt >

_OutIt _Format_default ( const match_results< _BidIt, _Alloc > &  _Match, _OutIt  _Out, _InIt  _First, _InIt  _Last, regex_constants::match_flag_type  _Flags = regex_constants::format_default  )

inline

    {   // format with ECMAScript rules
    while (_First !=_Last)
        {   // process one character or escape sequence
        if (*_First != '$')
            *_Out++ = *_First++;
        else if (++_First == _Last)
            ;
        else if (*_First == '$')
            {   // replace $$
            *_Out++ = '$';
            ++_First;
            }
        else if (*_First == '`')
            {   // replace $`
            _Out = _Copy_impl(_Match.prefix().first,
                _Match.prefix().second, _Out);
            ++_First;
            }
        else if (*_First == '\'')
            {   // replace $'
            _Out = _Copy_impl(_Match.suffix().first,
                _Match.suffix().second, _Out);
            ++_First;
            }
        else
            {   // replace capture group descriptors
            int n = -1;
            if (*_First == '&')
                {   // replace $&
                n = 0;
                ++_First;
                }
            else if (_Isdigit(*_First))
                {   // replace $n, $nn
                n = *_First++ - '0';
                if (_First != _Last && _Isdigit(*_First))
                    {   // process second digit
                    n *= 10;
                    n += *_First++ - '0';
                    }
                }
            else
                {   // replace $x
                *_Out++ = '$';
                *_Out++ = *_First++;
                }
            if (0 <= n && n < (int)_Match.size())
                _Out = _Copy_impl(_Match._At(n).first,
                    _Match._At(n).second, _Out);
            }
        }
    return (_Out);
    }

template<class _BidIt , class _Alloc , class _InIt , class _OutIt >

_OutIt _Format_sed ( const match_results< _BidIt, _Alloc > &  _Match, _OutIt  _Out, _InIt  _First, _InIt  _Last, regex_constants::match_flag_type  _Flags = regex_constants::format_default  )

inline

    {   // format with sed rules
    while (_First != _Last)
        {   // process one character or escape sequence
        if (*_First == '&')
            {   // replace with full match
            _Out = _Copy_impl(_Match._At(0).first,
                _Match._At(0).second, _Out);
            ++_First;
            }
        else if (*_First != '\\')
            *_Out++ = *_First++;
        else if (++_First == _Last)
            ;
        else if (_Isdigit(*_First))
            {   // replace \n
            int n = *_First++ - '0';
            _Out = _Copy_impl(_Match._At(n).first,
                _Match._At(n).second, _Out);
            }
        else
            *_Out++ = *_First++;
        }
    return (_Out);
    }

template<class _BidIt , class _Elem >

_BidIt _Lookup_coll ( _BidIt  _First, _BidIt  _Last, const _Sequence< _Elem > *  _Eq  )

inline

    {   // look for collation element [_First, _Last) in _Eq
    while (_Eq)
        {   // look for sequence of elements that are the right size
        for (int _Ix = 0; _Ix < _Eq->_Data._Size(); _Ix += _Eq->_Sz)
            {   // look for character range
            _BidIt _Res = _First;
            for (size_t _Jx = 0; _Jx < _Eq->_Sz; ++_Jx)
                {   // check current character
                if (*_Res++ != *(_Eq->_Data._Str() + _Ix + _Jx))
                    break;
                }
            if (_Res == _Last)
                return (_Last);
            }
        _Eq = _Eq->_Next;
        }
    return (_First);
    }

template<class _Elem , class _RxTraits >

bool _Lookup_equiv ( _Elem  _Ch, const _Sequence< _Elem > *  _Eq, const _RxTraits &  _Traits  )

inline

    {   // check whether _Ch is in _Eq
    typename _RxTraits::string_type _Str0;
    typename _RxTraits::string_type _Str1(1, _Ch);
    _Str1 = _Traits.transform_primary(_Str1.begin(), _Str1.end());
    while (_Eq)
        {   // look for sequence of elements that are the right size
        for (int _Ix = 0; _Ix < _Eq->_Data._Size(); _Ix += _Eq->_Sz)
            {   // look for _Ch
            _Str0.assign(_Eq->_Data._Str() + _Ix, _Eq->_Sz);
            _Str0 = _Traits.transform_primary(_Str0.begin(), _Str0.end());
            if (_Str0 == _Str1)
                return (true);
            }
        _Eq = _Eq->_Next;
        }
    return (false);
    }

template<class _Elem >

bool _Lookup_range ( _Elem  _Ch, const _Buf< _Elem > *  _Bufptr  )

inline

    {   // check whether _Ch is in _Buf
    for (int _Ix = 0; _Ix < _Bufptr->_Size(); _Ix += 2)
        {   // check current position
        if (_Bufptr->_At(_Ix) <= _Ch
            && _Ch <= _Bufptr->_At(_Ix + 1))
                return (true);
        }
    return (false);
    }

_CRTIMP2_PURE _NO_RETURN

(

__CLRCALL_PURE_OR_CDECL

_Xregex_errorregex_constants::error_type _Code

)

template<class _BidIt , class _Alloc , class _Elem , class _RxTraits , class _It >

bool _Regex_match ( _It  _First, _It  _Last, match_results< _BidIt, _Alloc > *  _Matches, const basic_regex< _Elem, _RxTraits > &  _Re, regex_constants::match_flag_type  _Flgs, bool  _Full  )

inline

    {   // try to match regular expression to target text
    if (_Re._Empty())
        return (false);
    _Matcher<_BidIt, _Elem, _RxTraits, _It> _Mx(_First, _Last,
        _Re._Get_traits(), _Re._Get(), _Re.mark_count() + 1, _Re.flags(),
            _Flgs);
    return (_Mx._Match(_Matches, _Full));
    }

template<class _OutIt , class _BidIt , class _RxTraits , class _Elem , class _Traits , class _Alloc >

_OutIt _Regex_replace ( _OutIt  _Result, _BidIt  _First, _BidIt  _Last, const basic_regex< _Elem, _RxTraits > &  _Re, const basic_string< _Elem, _Traits, _Alloc > &  _Fmt, regex_constants::match_flag_type  _Flgs  )

inline

    {   // search and replace
    match_results<_BidIt> _Matches;
    _BidIt _Pos = _First;
    regex_constants::match_flag_type _Flags = _Flgs;
    regex_constants::match_flag_type _Not_null =
        (regex_constants::match_flag_type)0;

    while (regex_search(_Pos, _Last, _Matches, _Re, _Flags | _Not_null))
        {   // replace at each match
        if (!(_Flgs & regex_constants::format_no_copy))
            _Result = _Copy_impl(_Matches.prefix().first,
                _Matches.prefix().second, _Result);
        _Result = _Matches._Format(_Result,
            _Unchecked(_Fmt.begin()), _Unchecked(_Fmt.end()), _Flags);

        _Pos = _Matches[0].second;
        if (_Pos == _Last
            || _Flgs & regex_constants::format_first_only)
            break;

        if (_Matches[0].first == _Matches[0].second)
            _Not_null = regex_constants::_Match_not_null;
        else
            {   // non-null match, recognize earlier text
            _Not_null = (regex_constants::match_flag_type)0;
            _Flags |= regex_constants::match_prev_avail;
            }
        }
    return (_Flgs & regex_constants::format_no_copy
        ? _Result : _Copy_impl(_Pos, _Last, _Result));
    }

template<class _BidIt , class _Alloc , class _Elem , class _RxTraits , class _It >

bool _Regex_search ( _It  _First, _It  _Last, match_results< _BidIt, _Alloc > *  _Matches, const basic_regex< _Elem, _RxTraits > &  _Re, regex_constants::match_flag_type  _Flgs, _It  _Org  )

inline

    {   // search for regular expression match in target text
    _DEBUG_RANGE(_First, _Last);
    if (_Re._Empty())
        return (false);
    bool _Found = false;
    _It _Begin = _First;
    _Matcher<_BidIt, _Elem, _RxTraits, _It> _Mx(_First, _Last,
        _Re._Get_traits(), _Re._Get(), _Re.mark_count() + 1, _Re.flags(),
            _Flgs);

    if (_Mx._Match(_Matches, false))
        _Found = true;
    else if (_First == _Last
        || _Flgs & regex_constants::match_continuous)
        ;
    else
        {   // try more on suffixes
        _Mx._Setf(regex_constants::match_prev_avail);
        _Mx._Clearf(regex_constants::_Match_not_null);
        while ((_First = _Mx._Skip(++_First, _Last)) != _Last)
            if (_Mx._Match(_First, _Matches, false))
                {   // found match starting at _First
                _Found = true;
                break;
                }
        if (!_Found && _Mx._Match(_Last, _Matches, false))
            _Found = true;
        }
    if (_Found && _Matches)
        {   // update _Matches
        _Matches->_Org = _Org;
        _Matches->_Pfx().first = _Begin;
        }
    return (_Found);
    }

template<class _InIt1 , class _InIt2 , class _Pr >

bool _Same	(	_InIt1	_First1,
		_InIt1	_Last1,
		_InIt2	_First2,
		_InIt2	_Last2,
		_Pr	_Pred
	)

    {   // return true if two sequences match using _Pred
    while (_First1 != _Last1 && _First2 != _Last2)
        if (!_Pred(*_First1++, *_First2++))
            return (false);
    return (_First1 == _Last1 && _First2 == _Last2);
    }

template<class _BidIt >

bool operator!= ( const sub_match< _BidIt > &  _Left, const sub_match< _BidIt > &  _Right  )

inline

    {   // test for inequality
    return (!(_Left == _Right));
    }

template<class _BidIt >

bool operator!= ( const _REGEX_VALT(_BidIt)*  _Left, const sub_match< _BidIt > &  _Right  )

inline

    {   // test for inequality
    return (!(_Left == _Right));
    }

template<class _BidIt >

bool operator!= ( const sub_match< _BidIt > &  _Left, const _REGEX_VALT(_BidIt)*  _Right  )

inline

    {   // test for inequality
    return (!(_Left == _Right));
    }

template<class _BidIt >

bool operator!= ( const _REGEX_VALT(_BidIt)&  _Left, const sub_match< _BidIt > &  _Right  )

inline

    {   // test for inequality
    return (!(_Left == _Right));
    }

template<class _BidIt >

bool operator!= ( const sub_match< _BidIt > &  _Left, const _REGEX_VALT(_BidIt)&  _Right  )

inline

    {   // test for inequality
    return (!(_Left == _Right));
    }

template<class _BidIt , class _Traits , class _Alloc >

bool operator!= ( const sub_match< _BidIt > &  _Left, const basic_string< _REGEX_VALT(_BidIt), _Traits, _Alloc > &  _Right  )

inline

    {   // test for inequality
    return (!(_Left == _Right));
    }

template<class _BidIt , class _Traits , class _Alloc >

bool operator!= ( const basic_string< _REGEX_VALT(_BidIt), _Traits, _Alloc > &  _Left, const sub_match< _BidIt > &  _Right  )

inline

    {   // test for inequality
    return (!(_Left == _Right));
    }

template<class _BidIt , class _Alloc >

bool operator!=	(	const match_results< _BidIt, _Alloc > &	_Left,
		const match_results< _BidIt, _Alloc > &	_Right
	)

    {   // compare results for inequality
    return (!(_Left == _Right));
    }

template<class _BidIt >

bool operator< ( const sub_match< _BidIt > &  _Left, const sub_match< _BidIt > &  _Right  )

inline

    {   // test if _Left < _Right
    return (_Left.compare(_Right) < 0);
    }

template<class _BidIt >

bool operator< ( const _REGEX_VALT(_BidIt)*  _Left, const sub_match< _BidIt > &  _Right  )

inline

    {   // test if _Left < _Right
    return (0 < _Right.compare(_Left));
    }

template<class _BidIt >

bool operator< ( const sub_match< _BidIt > &  _Left, const _REGEX_VALT(_BidIt)*  _Right  )

inline

    {   // test if _Left < _Right
    return (_Left.compare(_Right) < 0);
    }

template<class _BidIt >

bool operator< ( const _REGEX_VALT(_BidIt)&  _Left, const sub_match< _BidIt > &  _Right  )

inline

    {   // test if _Left < _Right
    typename sub_match<_BidIt>::string_type _Str(1, _Left);
    return (0 < _Right.compare(_Str));
    }

template<class _BidIt >

bool operator< ( const sub_match< _BidIt > &  _Left, const _REGEX_VALT(_BidIt)&  _Right  )

inline

    {   // test if _Left < _Right
    typename sub_match<_BidIt>::string_type _Str(1, _Right);
    return (_Left.compare(_Str) < 0);
    }

template<class _BidIt , class _Traits , class _Alloc >

bool operator< ( const sub_match< _BidIt > &  _Left, const basic_string< _REGEX_VALT(_BidIt), _Traits, _Alloc > &  _Right  )

inline

    {   // test if _Left < _Right
    return (_Left.compare(_Right.c_str()) < 0);
    }

template<class _BidIt , class _Traits , class _Alloc >

bool operator< ( const basic_string< _REGEX_VALT(_BidIt), _Traits, _Alloc > &  _Left, const sub_match< _BidIt > &  _Right  )

inline

    {   // test if _Left < _Right
    return (0 < _Right.compare(_Left.c_str()));
    }

template<class _Elem , class _Traits , class _BidIt >

basic_ostream<_Elem, _Traits>& operator<<	(	basic_ostream< _Elem, _Traits > &	_Ostr,
		const sub_match< _BidIt > &	_Match
	)

    {   // insert into basic_ostream
    return (_Ostr << _Match.str());
    }

template<class _BidIt >

bool operator<= ( const sub_match< _BidIt > &  _Left, const sub_match< _BidIt > &  _Right  )

inline

    {   // test if _Left <= _Right
    return (!(_Right < _Left));
    }

template<class _BidIt >

bool operator<= ( const _REGEX_VALT(_BidIt)*  _Left, const sub_match< _BidIt > &  _Right  )

inline

    {   // test if _Left <= _Right
    return (!(_Right < _Left));
    }

template<class _BidIt >

bool operator<= ( const sub_match< _BidIt > &  _Left, const _REGEX_VALT(_BidIt)*  _Right  )

inline

    {   // test if _Left <= _Right
    return (!(_Right < _Left));
    }

template<class _BidIt >

bool operator<= ( const _REGEX_VALT(_BidIt)&  _Left, const sub_match< _BidIt > &  _Right  )

inline

    {   // test if _Left <= _Right
    return (!(_Right < _Left));
    }

template<class _BidIt >

bool operator<= ( const sub_match< _BidIt > &  _Left, const _REGEX_VALT(_BidIt)&  _Right  )

inline

    {   // test if _Left <= _Right
    return (!(_Right < _Left));
    }

template<class _BidIt , class _Traits , class _Alloc >

bool operator<= ( const sub_match< _BidIt > &  _Left, const basic_string< _REGEX_VALT(_BidIt), _Traits, _Alloc > &  _Right  )

inline

    {   // test if _Left <= _Right
    return (!(_Right < _Left));
    }

template<class _BidIt , class _Traits , class _Alloc >

bool operator<= ( const basic_string< _REGEX_VALT(_BidIt), _Traits, _Alloc > &  _Left, const sub_match< _BidIt > &  _Right  )

inline

    {   // test if _Left <= _Right
    return (!(_Right < _Left));
    }

template<class _BidIt >

bool operator== ( const sub_match< _BidIt > &  _Left, const sub_match< _BidIt > &  _Right  )

inline

    {   // test for equality
    return (_Left.compare(_Right) == 0);
    }

template<class _BidIt >

bool operator== ( const _REGEX_VALT(_BidIt)*  _Left, const sub_match< _BidIt > &  _Right  )

inline

    {   // test for equality
    return (_Right.compare(_Left) == 0);
    }

template<class _BidIt >

bool operator== ( const sub_match< _BidIt > &  _Left, const _REGEX_VALT(_BidIt)*  _Right  )

inline

    {   // test for equality
    return (_Left.compare(_Right) == 0);
    }

template<class _BidIt >

bool operator== ( const _REGEX_VALT(_BidIt)&  _Left, const sub_match< _BidIt > &  _Right  )

inline

    {   // test for equality
    typename sub_match<_BidIt>::string_type _Str(1, _Left);
    return (_Right.compare(_Str) == 0);
    }

template<class _BidIt >

bool operator== ( const sub_match< _BidIt > &  _Left, const _REGEX_VALT(_BidIt)&  _Right  )

inline

    {   // test for equality
    typename sub_match<_BidIt>::string_type _Str(1, _Right);
    return (_Left.compare(_Str) == 0);
    }

template<class _BidIt , class _Traits , class _Alloc >

bool operator== ( const sub_match< _BidIt > &  _Left, const basic_string< _REGEX_VALT(_BidIt), _Traits, _Alloc > &  _Right  )

inline

    {   // test for equality
    return (_Left.compare(_Right.c_str()) == 0);
    }

template<class _BidIt , class _Traits , class _Alloc >

bool operator== ( const basic_string< _REGEX_VALT(_BidIt), _Traits, _Alloc > &  _Left, const sub_match< _BidIt > &  _Right  )

inline

    {   // test for equality
    return (_Right.compare(_Left.c_str()) == 0);
    }

template<class _BidIt , class _Alloc >

bool operator==	(	const match_results< _BidIt, _Alloc > &	_Left,
		const match_results< _BidIt, _Alloc > &	_Right
	)

    {   // compare results for equality
    if (!_Left.ready() && !_Right.ready())
        return (true);
    else if (!_Left.ready() || !_Right.ready())
        return (false);
    else if (_Left.empty() && _Right.empty())
        return (true);
    else if (_Left.empty() || _Right.empty())
        return (false);
    else
        return (_Left.size() == _Right.size()
            && _Left.prefix() == _Right.prefix()
            && _Left.suffix() == _Right.suffix()
            && _STD equal(_Left.begin(), _Left.end(), _Right.begin()));
    }

template<class _BidIt >

bool operator> ( const sub_match< _BidIt > &  _Left, const sub_match< _BidIt > &  _Right  )

inline

    {   // test if _Left > _Right
    return (_Right < _Left);
    }

template<class _BidIt >

bool operator> ( const _REGEX_VALT(_BidIt)*  _Left, const sub_match< _BidIt > &  _Right  )

inline

    {   // test if _Left > _Right
    return (_Right < _Left);
    }

template<class _BidIt >

bool operator> ( const sub_match< _BidIt > &  _Left, const _REGEX_VALT(_BidIt)*  _Right  )

inline

    {   // test if _Left > _Right
    return (_Right < _Left);
    }

template<class _BidIt >

bool operator> ( const _REGEX_VALT(_BidIt)&  _Left, const sub_match< _BidIt > &  _Right  )

inline

    {   // test if _Left > _Right
    return (_Right < _Left);
    }

template<class _BidIt >

bool operator> ( const sub_match< _BidIt > &  _Left, const _REGEX_VALT(_BidIt)&  _Right  )

inline

    {   // test if _Left > _Right
    return (_Right < _Left);
    }

template<class _BidIt , class _Traits , class _Alloc >

bool operator> ( const sub_match< _BidIt > &  _Left, const basic_string< _REGEX_VALT(_BidIt), _Traits, _Alloc > &  _Right  )

inline

    {   // test if _Left > _Right
    return (_Right < _Left);
    }

template<class _BidIt , class _Traits , class _Alloc >

bool operator> ( const basic_string< _REGEX_VALT(_BidIt), _Traits, _Alloc > &  _Left, const sub_match< _BidIt > &  _Right  )

inline

    {   // test if _Left > _Right
    return (_Right < _Left);
    }

template<class _BidIt >

bool operator>= ( const sub_match< _BidIt > &  _Left, const sub_match< _BidIt > &  _Right  )

inline

    {   // test if _Left >= _Right
    return (!(_Left < _Right));
    }

template<class _BidIt >

bool operator>= ( const _REGEX_VALT(_BidIt)*  _Left, const sub_match< _BidIt > &  _Right  )

inline

    {   // test if _Left >= _Right
    return (!(_Left < _Right));
    }

template<class _BidIt >

bool operator>= ( const sub_match< _BidIt > &  _Left, const _REGEX_VALT(_BidIt)*  _Right  )

inline

    {   // test if _Left >= _Right
    return (!(_Left < _Right));
    }

template<class _BidIt >

bool operator>= ( const _REGEX_VALT(_BidIt)&  _Left, const sub_match< _BidIt > &  _Right  )

inline

    {   // test if _Left >= _Right
    return (!(_Left < _Right));
    }

template<class _BidIt >

bool operator>= ( const sub_match< _BidIt > &  _Left, const _REGEX_VALT(_BidIt)&  _Right  )

inline

    {   // test if _Left >= _Right
    return (!(_Left < _Right));
    }

template<class _BidIt , class _Traits , class _Alloc >

bool operator>= ( const sub_match< _BidIt > &  _Left, const basic_string< _REGEX_VALT(_BidIt), _Traits, _Alloc > &  _Right  )

inline

    {   // test if _Left >= _Right
    return (!(_Left < _Right));
    }

template<class _BidIt , class _Traits , class _Alloc >

bool operator>= ( const basic_string< _REGEX_VALT(_BidIt), _Traits, _Alloc > &  _Left, const sub_match< _BidIt > &  _Right  )

inline

    {   // test if _Left >= _Right
    return (!(_Left < _Right));
    }

_Node_flags operator^= ( _Node_flags &  _Left, _Node_flags  _Right  )

inline

    {   // bitwise xor
    return (_Left = _Node_flags((int)_Left ^ _Right));
    }

_Node_flags operator| ( _Node_flags  _Left, _Node_flags  _Right  )

inline

    {   // bitwise or
    return (_Node_flags((int)_Left | _Right));
    }

_Node_flags operator|= ( _Node_flags &  _Left, _Node_flags  _Right  )

inline

    {   // bitwise or
    return (_Left = _Node_flags((int)_Left | _Right));
    }

template<class _BidIt , class _Alloc , class _Elem , class _RxTraits >

bool regex_match ( _BidIt  _First, _BidIt  _Last, match_results< _BidIt, _Alloc > &  _Matches, const basic_regex< _Elem, _RxTraits > &  _Re, regex_constants::match_flag_type  _Flgs = regex_constants::match_default  )

inline

    {   // try to match regular expression to target text
    return (_Regex_match(_First, _Last,
        &_Matches, _Re, _Flgs, true));
    }

template<class _BidIt , class _Elem , class _RxTraits >

bool regex_match ( _BidIt  _First, _BidIt  _Last, const basic_regex< _Elem, _RxTraits > &  _Re, regex_constants::match_flag_type  _Flgs = regex_constants::match_default  )

inline

    {   // try to match regular expression to target text
    return (_Regex_match(_First, _Last,
        (match_results<_BidIt> *)0, _Re,
            _Flgs | regex_constants::match_any, true));
    }

template<class _Elem , class _RxTraits >

bool regex_match ( _In_z_ const _Elem *  _Str, const basic_regex< _Elem, _RxTraits > &  _Re, regex_constants::match_flag_type  _Flgs = regex_constants::match_default  )

inline

    {   // try to match regular expression to target text
    const _Elem *_Last = _Str + char_traits<_Elem>::length(_Str);
    return (_Regex_match(_Str, _Last,
        (match_results<const _Elem *> *)0, _Re,
            _Flgs | regex_constants::match_any, true));
    }

template<class _Elem , class _Alloc , class _RxTraits >

bool regex_match ( _In_z_ const _Elem *  _Str, match_results< const _Elem *, _Alloc > &  _Matches, const basic_regex< _Elem, _RxTraits > &  _Re, regex_constants::match_flag_type  _Flgs = regex_constants::match_default  )

inline

    {   // try to match regular expression to target text
    const _Elem *_Last = _Str + char_traits<_Elem>::length(_Str);
    return (_Regex_match(_Str, _Last,
        &_Matches, _Re, _Flgs, true));
    }

template<class _StTraits , class _StAlloc , class _Alloc , class _Elem , class _RxTraits >

bool regex_match ( const basic_string< _Elem, _StTraits, _StAlloc > &  _Str, match_results< typename basic_string< _Elem, _StTraits, _StAlloc >::const_iterator, _Alloc > &  _Matches, const basic_regex< _Elem, _RxTraits > &  _Re, regex_constants::match_flag_type  _Flgs = regex_constants::match_default  )

inline

    {   // try to match regular expression to target text
    return (_Regex_match(_Str.begin(), _Str.end(),
        &_Matches, _Re, _Flgs, true));
    }

template<class _StTraits , class _StAlloc , class _Elem , class _RxTraits >

bool regex_match ( const basic_string< _Elem, _StTraits, _StAlloc > &  _Str, const basic_regex< _Elem, _RxTraits > &  _Re, regex_constants::match_flag_type  _Flgs = regex_constants::match_default  )

inline

    {   // try to match regular expression to target text
    typedef typename basic_string<_Elem, _StTraits, _StAlloc>
        ::const_iterator _Iter;
    return (_Regex_match(_Str.begin(), _Str.end(),
        (match_results<_Iter> *)0, _Re,
            _Flgs | regex_constants::match_any, true));
    }

template<class _OutIt , class _BidIt , class _RxTraits , class _Elem , class _Traits , class _Alloc >

_OutIt regex_replace ( _OutIt  _Result, _BidIt  _First, _BidIt  _Last, const basic_regex< _Elem, _RxTraits > &  _Re, const basic_string< _Elem, _Traits, _Alloc > &  _Fmt, regex_constants::match_flag_type  _Flgs = regex_constants::match_default  )

inline

    {   // search and replace, iterator result, string format
    return (_Rechecked(_Result,
        _Regex_replace(_Unchecked(_Result),
            _Unchecked(_First), _Unchecked(_Last),
                _Re, _Fmt, _Flgs)));
    }

template<class _OutIt , class _BidIt , class _RxTraits , class _Elem >

_OutIt regex_replace ( _OutIt  _Result, _BidIt  _First, _BidIt  _Last, const basic_regex< _Elem, _RxTraits > &  _Re, const _Elem *  _Ptr, regex_constants::match_flag_type  _Flgs = regex_constants::match_default  )

inline

    {   // search and replace, iterator result, NTBS format
    const basic_string<_Elem> _Fmt(_Ptr);
    return (regex_replace(_Result,
        _First, _Last, _Re, _Fmt, _Flgs));
    }

template<class _RxTraits , class _Elem , class _Traits1 , class _Alloc1 , class _Traits2 , class _Alloc2 >

basic_string<_Elem, _Traits1, _Alloc1> regex_replace	(	const basic_string< _Elem, _Traits1, _Alloc1 > &	_Str,
		const basic_regex< _Elem, _RxTraits > &	_Re,
		const basic_string< _Elem, _Traits2, _Alloc2 > &	_Fmt,
		regex_constants::match_flag_type	_Flgs = regex_constants::match_default
	)

    {   // search and replace, string result, string target, string format
    basic_string<_Elem, _Traits1, _Alloc1> _Res;
    regex_replace(_STD back_inserter(_Res), _Str.begin(), _Str.end(),
        _Re, _Fmt, _Flgs);
    return (_Res);
    }

template<class _RxTraits , class _Elem , class _Traits1 , class _Alloc1 >

basic_string<_Elem, _Traits1, _Alloc1> regex_replace	(	const basic_string< _Elem, _Traits1, _Alloc1 > &	_Str,
		const basic_regex< _Elem, _RxTraits > &	_Re,
		const _Elem *	_Ptr,
		regex_constants::match_flag_type	_Flgs = regex_constants::match_default
	)

    {   // search and replace, string result, string target, NTBS format
    basic_string<_Elem, _Traits1, _Alloc1> _Res;
    const basic_string<_Elem> _Fmt(_Ptr);
    regex_replace(_STD back_inserter(_Res), _Str.begin(), _Str.end(),
        _Re, _Fmt, _Flgs);
    return (_Res);
    }

template<class _RxTraits , class _Elem , class _Traits2 , class _Alloc2 >

basic_string<_Elem> regex_replace	(	const _Elem *	_Pstr,
		const basic_regex< _Elem, _RxTraits > &	_Re,
		const basic_string< _Elem, _Traits2, _Alloc2 > &	_Fmt,
		regex_constants::match_flag_type	_Flgs = regex_constants::match_default
	)

    {   // search and replace, string result, NTBS target, string format
    basic_string<_Elem> _Res;
    const basic_string<_Elem> _Str(_Pstr);
    regex_replace(_STD back_inserter(_Res), _Str.begin(), _Str.end(),
        _Re, _Fmt, _Flgs);
    return (_Res);
    }

template<class _RxTraits , class _Elem >

basic_string<_Elem> regex_replace	(	const _Elem *	_Pstr,
		const basic_regex< _Elem, _RxTraits > &	_Re,
		const _Elem *	_Ptr,
		regex_constants::match_flag_type	_Flgs = regex_constants::match_default
	)

    {   // search and replace, string result, NTBS target, NTBS format
    basic_string<_Elem> _Res;
    const basic_string<_Elem> _Str(_Pstr);
    const basic_string<_Elem> _Fmt(_Ptr);
    regex_replace(_STD back_inserter(_Res), _Str.begin(), _Str.end(),
        _Re, _Fmt, _Flgs);
    return (_Res);
    }

template<class _BidIt , class _Alloc , class _Elem , class _RxTraits >

bool regex_search ( _BidIt  _First, _BidIt  _Last, match_results< _BidIt, _Alloc > &  _Matches, const basic_regex< _Elem, _RxTraits > &  _Re, regex_constants::match_flag_type  _Flgs = regex_constants::match_default  )

inline

    {   // search for regular expression match in target text
    return (_Regex_search(_First, _Last, &_Matches, _Re, _Flgs, _First));
    }

template<class _BidIt , class _Elem , class _RxTraits >

bool regex_search ( _BidIt  _First, _BidIt  _Last, const basic_regex< _Elem, _RxTraits > &  _Re, regex_constants::match_flag_type  _Flgs = regex_constants::match_default  )

inline

    {   // search for regular expression match in target text
    return (_Regex_search(_First, _Last,
        (match_results<_BidIt> *)0, _Re,
            _Flgs | regex_constants::match_any, _First));
    }

template<class _Elem , class _RxTraits >

bool regex_search ( _In_z_ const _Elem *  _Str, const basic_regex< _Elem, _RxTraits > &  _Re, regex_constants::match_flag_type  _Flgs = regex_constants::match_default  )

inline

    {   // search for regular expression match in target text
    const _Elem *_Last = _Str + char_traits<_Elem>::length(_Str);
    return (_Regex_search(_Str, _Last,
        (match_results<const _Elem *> *)0, _Re,
            _Flgs | regex_constants::match_any, _Str));
    }

template<class _Elem , class _Alloc , class _RxTraits >

bool regex_search ( _In_z_ const _Elem *  _Str, match_results< const _Elem *, _Alloc > &  _Matches, const basic_regex< _Elem, _RxTraits > &  _Re, regex_constants::match_flag_type  _Flgs = regex_constants::match_default  )

inline

    {   // search for regular expression match in target text
    const _Elem *_Last = _Str + char_traits<_Elem>::length(_Str);
    return (_Regex_search(_Str, _Last, &_Matches, _Re, _Flgs, _Str));
    }

template<class _StTraits , class _StAlloc , class _Alloc , class _Elem , class _RxTraits >

bool regex_search ( const basic_string< _Elem, _StTraits, _StAlloc > &  _Str, match_results< typename basic_string< _Elem, _StTraits, _StAlloc >::const_iterator, _Alloc > &  _Matches, const basic_regex< _Elem, _RxTraits > &  _Re, regex_constants::match_flag_type  _Flgs = regex_constants::match_default  )

inline

    {   // search for regular expression match in target text
    return (_Regex_search(_Str.begin(), _Str.end(),
        &_Matches, _Re, _Flgs, _Str.begin()));
    }

template<class _StTraits , class _StAlloc , class _Elem , class _RxTraits >

bool regex_search ( const basic_string< _Elem, _StTraits, _StAlloc > &  _Str, const basic_regex< _Elem, _RxTraits > &  _Re, regex_constants::match_flag_type  _Flgs = regex_constants::match_default  )

inline

    {   // search for regular expression match in target text
    typedef typename basic_string<_Elem, _StTraits, _StAlloc>
        ::const_pointer _Iter;

    const _Elem *_First = _Str.c_str();
    const _Elem *_Last = _First + _Str.size();
    return (_Regex_search(_First, _Last,
        (match_results<_Iter> *)0, _Re,
            _Flgs | regex_constants::match_any, _First));
    }

template<class _Elem , class _RxTraits >

void swap	(	basic_regex< _Elem, _RxTraits > &	_Left,
		basic_regex< _Elem, _RxTraits > &	_Right
	)

    {   // exchange contents of _Left with _Right
    _Left.swap(_Right);
    }

template<class _BidIt , class _Alloc >

void swap	(	match_results< _BidIt, _Alloc > &	_Left,
		match_results< _BidIt, _Alloc > &	_Right
	)

    {   // exchange contents of _Left with _Right
    _Left.swap(_Right);
    }

Variable Documentation

const int _ARRAY_THRESHOLD = 4

const unsigned int _Awk_flags

static

Initial value:

=
    _Extended_flags | _L_esc_oct | _L_esc_ffn | _L_esc_ffnx | _L_ident_awk

const unsigned int _Basic_flags

static

Initial value:

=
    _L_bckr | _L_lim_bckr | _L_anch_rstr
        | _L_star_beg | _L_empty_grp | _L_brk_rstr | _L_mtch_long

const int _Bmp_chrs = 1 << _Bmp_shift

const int _Bmp_mask = _Bmp_chrs - 1

const int _Bmp_max = 256

const int _Bmp_shift = 3

const int _Bmp_size = (_Bmp_max + _Bmp_chrs - 1) / _Bmp_chrs

const int _BRE_MAX_GRP = 9

const int _Buf_incr = 16

const unsigned int _ECMA_flags

static

Initial value:

=
    _L_ext_rep | _L_alt_pipe | _L_nex_grp | _L_nex_rep | _L_nc_grp
        | _L_asrt_gen | _L_asrt_wrd | _L_bckr | _L_ngr_rep
        | _L_esc_uni | _L_esc_hex | _L_esc_bsl | _L_esc_ffn | _L_esc_wsd
        | _L_esc_ctrl | _L_bzr_chr | _L_grp_esc | _L_ident_ECMA
        | _L_empty_grp

const unsigned int _Egrep_flags

static

Initial value:

=
    _Extended_flags | _L_alt_nl | _L_no_nl

const unsigned int _Extended_flags

static

Initial value:

=
    _L_ext_rep | _L_alt_pipe | _L_nex_grp | _L_nex_rep | _L_ident_ERE
    | _L_paren_bal | _L_brk_rstr | _L_mtch_long

const unsigned int _Grep_flags

static

Initial value:

=
    _Basic_flags | _L_alt_nl | _L_no_nl

const char _Meta_map[]

static

Initial value:

= { 
    _Meta_lpar, _Meta_rpar, _Meta_dlr, _Meta_caret,
    _Meta_dot, _Meta_star, _Meta_plus, _Meta_query,
    _Meta_lsq, _Meta_rsq, _Meta_bar, _Meta_esc,
    _Meta_dash, _Meta_lbr, _Meta_rbr, _Meta_comma,
    _Meta_colon, _Meta_equal, _Meta_exc, _Meta_nl,
    _Meta_cr, _Meta_bsp,
    0}