STLdoc
STLdocumentation
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros
Classes | Namespaces | Macros | Typedefs | Enumerations | Functions | Variables
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
 
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
 

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_CHAR_CLASS_NAME(n, c)   {n, L ## 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_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
}
 

Functions

_CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL _Xregex_error (regex_constants::error_type _Code)
 
template<class _Traits , class _FwdIt1 , class _FwdIt2 >
int _Iter_compare3 (_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2, true_type)
 
template<class _Traits , class _FwdIt1 , class _FwdIt2 >
int _Iter_compare3 (_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2, false_type)
 
template<class _Traits , class _FwdIt1 , class _FwdIt2 >
int _Iter_compare2 (_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2)
 
template<class _Traits , class _FwdIt1 , class _FwdIt2 >
int _Iter_compare (_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2)
 
bool _Is_word (unsigned char _UCh)
 
bool _Is_word (char _Ch)
 
template<class _Elem >
bool _Is_word (_Elem _Ch)
 
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 _Iter_value_t< _BidIt > *_Left, const sub_match< _BidIt > &_Right)
 
template<class _BidIt >
bool operator!= (const _Iter_value_t< _BidIt > *_Left, const sub_match< _BidIt > &_Right)
 
template<class _BidIt >
bool operator< (const _Iter_value_t< _BidIt > *_Left, const sub_match< _BidIt > &_Right)
 
template<class _BidIt >
bool operator> (const _Iter_value_t< _BidIt > *_Left, const sub_match< _BidIt > &_Right)
 
template<class _BidIt >
bool operator<= (const _Iter_value_t< _BidIt > *_Left, const sub_match< _BidIt > &_Right)
 
template<class _BidIt >
bool operator>= (const _Iter_value_t< _BidIt > *_Left, const sub_match< _BidIt > &_Right)
 
template<class _BidIt >
bool operator== (const sub_match< _BidIt > &_Left, const _Iter_value_t< _BidIt > *_Right)
 
template<class _BidIt >
bool operator!= (const sub_match< _BidIt > &_Left, const _Iter_value_t< _BidIt > *_Right)
 
template<class _BidIt >
bool operator< (const sub_match< _BidIt > &_Left, const _Iter_value_t< _BidIt > *_Right)
 
template<class _BidIt >
bool operator> (const sub_match< _BidIt > &_Left, const _Iter_value_t< _BidIt > *_Right)
 
template<class _BidIt >
bool operator<= (const sub_match< _BidIt > &_Left, const _Iter_value_t< _BidIt > *_Right)
 
template<class _BidIt >
bool operator>= (const sub_match< _BidIt > &_Left, const _Iter_value_t< _BidIt > *_Right)
 
template<class _BidIt >
bool operator== (const _Iter_value_t< _BidIt > &_Left, const sub_match< _BidIt > &_Right)
 
template<class _BidIt >
bool operator!= (const _Iter_value_t< _BidIt > &_Left, const sub_match< _BidIt > &_Right)
 
template<class _BidIt >
bool operator< (const _Iter_value_t< _BidIt > &_Left, const sub_match< _BidIt > &_Right)
 
template<class _BidIt >
bool operator> (const _Iter_value_t< _BidIt > &_Left, const sub_match< _BidIt > &_Right)
 
template<class _BidIt >
bool operator<= (const _Iter_value_t< _BidIt > &_Left, const sub_match< _BidIt > &_Right)
 
template<class _BidIt >
bool operator>= (const _Iter_value_t< _BidIt > &_Left, const sub_match< _BidIt > &_Right)
 
template<class _BidIt >
bool operator== (const sub_match< _BidIt > &_Left, const _Iter_value_t< _BidIt > &_Right)
 
template<class _BidIt >
bool operator!= (const sub_match< _BidIt > &_Left, const _Iter_value_t< _BidIt > &_Right)
 
template<class _BidIt >
bool operator< (const sub_match< _BidIt > &_Left, const _Iter_value_t< _BidIt > &_Right)
 
template<class _BidIt >
bool operator> (const sub_match< _BidIt > &_Left, const _Iter_value_t< _BidIt > &_Right)
 
template<class _BidIt >
bool operator<= (const sub_match< _BidIt > &_Left, const _Iter_value_t< _BidIt > &_Right)
 
template<class _BidIt >
bool operator>= (const sub_match< _BidIt > &_Left, const _Iter_value_t< _BidIt > &_Right)
 
template<class _BidIt , class _Traits , class _Alloc >
bool operator== (const sub_match< _BidIt > &_Left, const basic_string< _Iter_value_t< _BidIt >, _Traits, _Alloc > &_Right)
 
template<class _BidIt , class _Traits , class _Alloc >
bool operator!= (const sub_match< _BidIt > &_Left, const basic_string< _Iter_value_t< _BidIt >, _Traits, _Alloc > &_Right)
 
template<class _BidIt , class _Traits , class _Alloc >
bool operator< (const sub_match< _BidIt > &_Left, const basic_string< _Iter_value_t< _BidIt >, _Traits, _Alloc > &_Right)
 
template<class _BidIt , class _Traits , class _Alloc >
bool operator> (const sub_match< _BidIt > &_Left, const basic_string< _Iter_value_t< _BidIt >, _Traits, _Alloc > &_Right)
 
template<class _BidIt , class _Traits , class _Alloc >
bool operator<= (const sub_match< _BidIt > &_Left, const basic_string< _Iter_value_t< _BidIt >, _Traits, _Alloc > &_Right)
 
template<class _BidIt , class _Traits , class _Alloc >
bool operator>= (const sub_match< _BidIt > &_Left, const basic_string< _Iter_value_t< _BidIt >, _Traits, _Alloc > &_Right)
 
template<class _BidIt , class _Traits , class _Alloc >
bool operator== (const basic_string< _Iter_value_t< _BidIt >, _Traits, _Alloc > &_Left, const sub_match< _BidIt > &_Right)
 
template<class _BidIt , class _Traits , class _Alloc >
bool operator!= (const basic_string< _Iter_value_t< _BidIt >, _Traits, _Alloc > &_Left, const sub_match< _BidIt > &_Right)
 
template<class _BidIt , class _Traits , class _Alloc >
bool operator< (const basic_string< _Iter_value_t< _BidIt >, _Traits, _Alloc > &_Left, const sub_match< _BidIt > &_Right)
 
template<class _BidIt , class _Traits , class _Alloc >
bool operator> (const basic_string< _Iter_value_t< _BidIt >, _Traits, _Alloc > &_Left, const sub_match< _BidIt > &_Right)
 
template<class _BidIt , class _Traits , class _Alloc >
bool operator<= (const basic_string< _Iter_value_t< _BidIt >, _Traits, _Alloc > &_Left, const sub_match< _BidIt > &_Right)
 
template<class _BidIt , class _Traits , class _Alloc >
bool operator>= (const basic_string< _Iter_value_t< _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_match1 (_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 _Alloc , class _Elem , class _RxTraits >
bool regex_match (const basic_string< _Elem, _StTraits, _StAlloc > &&, match_results< typename basic_string< _Elem, _StTraits, _StAlloc >::const_iterator, _Alloc > &, const basic_regex< _Elem, _RxTraits > &, regex_constants::match_flag_type=regex_constants::match_default)=delete
 
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_search1 (_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 _Alloc , class _Elem , class _RxTraits >
bool regex_search (const basic_string< _Elem, _StTraits, _StAlloc > &&, match_results< typename basic_string< _Elem, _StTraits, _StAlloc >::const_iterator, _Alloc > &, const basic_regex< _Elem, _RxTraits > &, regex_constants::match_flag_type=regex_constants::match_default)=delete
 
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_replace1 (_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)
 
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)
 
template<class _Elem >
bool _Lookup_range (unsigned int _Ch, const _Buf< _Elem > *_Bufptr)
 
template<class _Elem , class _RxTraits >
bool _Lookup_equiv (typename _RxTraits::_Uelem _Ch, const _Sequence< _Elem > *_Eq, const _RxTraits &_Traits)
 
template<class _BidIt , class _Elem >
_BidIt _Lookup_coll (_BidIt _First, _BidIt _Last, const _Sequence< _Elem > *_Eq)
 
void _Calculate_loop_simplicity (_Node_base *_Nx, _Node_base *_Ne, _Node_rep *_Outer_rep)
 

Variables

const unsigned int _BRE_MAX_GRP = 9U
 
const unsigned int _Bmp_max = 256U
 
const unsigned int _Bmp_shift = 3U
 
const unsigned int _Bmp_chrs = 1U << _Bmp_shift
 
const unsigned int _Bmp_mask = _Bmp_chrs - 1U
 
const unsigned int _Bmp_size = (_Bmp_max + _Bmp_chrs - 1U) / _Bmp_chrs
 
const unsigned int _Buf_incr = 16U
 
const unsigned int _ARRAY_THRESHOLD = 4U
 

Macro Definition Documentation

#define _ENHANCED_REGEX_VISUALIZER   0
#define _Isdigit (   x)    ('0' <= (x) && (x) <= '9')
#define _REGEX_
#define _REGEX_CHAR_CLASS_NAME (   n,
  c 
)    {n, L ## n, sizeof (n) / sizeof (n[0]) - 1, c}
#define _REGEX_MAX_COMPLEXITY_COUNT   10000000L /* set to 0 to disable */
#define _REGEX_MAX_STACK_COUNT   1000L /* set to 0 to disable */

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 
2227  { // describe language properties
2228  _L_ext_rep = 0x00000001, // + and ? repetitions
2229  _L_alt_pipe = 0x00000002, // uses '|' for alternation
2230  _L_alt_nl = 0x00000004, // uses '\n' for alternation (grep, egrep)
2231  _L_nex_grp = 0x00000008, // has non-escaped capture groups
2232  _L_nex_rep = 0x00000010, // has non-escaped repeats
2233  _L_nc_grp = 0x00000020, // has non-capture groups (?:xxx)
2234  _L_asrt_gen = 0x00000040, // has generalized assertions (?=xxx), (?!xxx)
2235  _L_asrt_wrd = 0x00000080, // has word boundary assertions (\b, \B)
2236  _L_bckr = 0x00000100, // has backreferences (ERE doesn't)
2237  _L_lim_bckr = 0x00000200, // has limited backreferences (BRE \1-\9)
2238  _L_ngr_rep = 0x00000400, // has non-greedy repeats
2239  _L_esc_uni = 0x00000800, // has Unicode escape sequences
2240  _L_esc_hex = 0x00001000, // has hexadecimal escape sequences
2241  _L_esc_oct = 0x00002000, // has octal escape sequences
2242  _L_esc_bsl = 0x00004000, // has escape backslash in character classes
2243  _L_esc_ffnx = 0x00008000, // has extra file escapes (\a and \b)
2244  _L_esc_ffn = 0x00010000, // has limited file escapes (\[fnrtv])
2245  _L_esc_wsd = 0x00020000, // has w, s, and d character set escapes
2246  _L_esc_ctrl = 0x00040000, // has control escape
2247  _L_no_nl = 0x00080000, // no newline in pattern or matching text
2248  _L_bzr_chr = 0x00100000, // \0 is a valid character constant
2249  _L_grp_esc = 0x00200000, // \ is special character in group
2250  _L_ident_ECMA = 0x00400000, // ECMA identity escape (not identifierpart)
2251  _L_ident_ERE = 0x00800000, // ERE identity escape (.[\*^$, plus {+?}()
2252  _L_ident_awk = 0x01000000, // awk identity escape ( ERE plus "/)
2253  _L_anch_rstr = 0x02000000, // anchor restricted to beginning/end
2254  _L_star_beg = 0x04000000, // star okay at beginning of RE/expr (BRE)
2255  _L_empty_grp = 0x08000000, // empty group allowed (ERE prohibits "()")
2256  _L_paren_bal = 0x10000000, // ')'/'}'/']' special only after '('/'{'/']'
2257  _L_brk_rstr = 0x20000000, // ']' not special when first character in set
2258  _L_mtch_long = 0x40000000, // find longest match (ERE, BRE)
2259  };
_L_nex_rep
Definition: regex:2232
_L_brk_rstr
Definition: regex:2257
_L_anch_rstr
Definition: regex:2253
_L_bzr_chr
Definition: regex:2248
_L_esc_bsl
Definition: regex:2242
_L_star_beg
Definition: regex:2254
_L_esc_uni
Definition: regex:2239
_L_esc_oct
Definition: regex:2241
_L_esc_ctrl
Definition: regex:2246
_L_asrt_wrd
Definition: regex:2235
_L_esc_ffn
Definition: regex:2244
_L_ident_ECMA
Definition: regex:2250
_L_grp_esc
Definition: regex:2249
_L_bckr
Definition: regex:2236
_L_ident_ERE
Definition: regex:2251
_L_empty_grp
Definition: regex:2255
_L_mtch_long
Definition: regex:2258
_L_esc_ffnx
Definition: regex:2243
_L_lim_bckr
Definition: regex:2237
_L_esc_hex
Definition: regex:2240
_L_ext_rep
Definition: regex:2228
_L_asrt_gen
Definition: regex:2234
_L_ident_awk
Definition: regex:2252
_L_nc_grp
Definition: regex:2233
_L_no_nl
Definition: regex:2247
_L_nex_grp
Definition: regex:2231
_L_esc_wsd
Definition: regex:2245
_L_ngr_rep
Definition: regex:2238
_L_paren_bal
Definition: regex:2256
_L_alt_nl
Definition: regex:2230
_L_alt_pipe
Definition: regex:2229
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 
53  { // meta character representations for parser
54  _Meta_lpar = '(',
55  _Meta_rpar = ')',
56  _Meta_dlr = '$',
57  _Meta_caret = '^',
58  _Meta_dot = '.',
59  _Meta_star = '*',
60  _Meta_plus = '+',
61  _Meta_query = '?',
62  _Meta_lsq = '[',
63  _Meta_rsq = ']',
64  _Meta_bar = '|',
65  _Meta_esc = '\\',
66  _Meta_dash = '-',
67  _Meta_lbr = '{',
68  _Meta_rbr = '}',
69  _Meta_comma = ',',
70  _Meta_colon = ':',
71  _Meta_equal = '=',
72  _Meta_exc = '!',
73  _Meta_eos = -1,
74  _Meta_nl = '\n',
75  _Meta_cr = '\r',
76  _Meta_bsp = '\b',
77  _Meta_chr = 0,
78 
79  _Esc_bsl = '\\',
80  _Esc_word = 'b',
81  _Esc_not_word = 'B',
82  _Esc_ctrl_a = 'a',
83  _Esc_ctrl_b = 'b',
84  _Esc_ctrl_f = 'f',
85  _Esc_ctrl_n = 'n',
86  _Esc_ctrl_r = 'r',
87  _Esc_ctrl_t = 't',
88  _Esc_ctrl_v = 'v',
89  _Esc_ctrl = 'c',
90  _Esc_hex = 'x',
91  _Esc_uni = 'u'
92  };
_Meta_eos
Definition: regex:73
_Meta_star
Definition: regex:59
_Meta_comma
Definition: regex:69
_Meta_rsq
Definition: regex:63
_Meta_exc
Definition: regex:72
_Meta_equal
Definition: regex:71
_Esc_ctrl_r
Definition: regex:86
_Esc_not_word
Definition: regex:81
_Esc_ctrl
Definition: regex:89
_Meta_bsp
Definition: regex:76
_Esc_ctrl_n
Definition: regex:85
_Meta_bar
Definition: regex:64
_Meta_caret
Definition: regex:57
_Meta_lpar
Definition: regex:54
_Meta_rbr
Definition: regex:68
_Esc_ctrl_b
Definition: regex:83
_Esc_hex
Definition: regex:90
_Meta_dash
Definition: regex:66
_Meta_chr
Definition: regex:77
_Esc_word
Definition: regex:80
_Meta_colon
Definition: regex:70
_Meta_lbr
Definition: regex:67
_Esc_ctrl_a
Definition: regex:82
_Meta_nl
Definition: regex:74
_Esc_ctrl_t
Definition: regex:87
_Meta_rpar
Definition: regex:55
_Meta_plus
Definition: regex:60
_Meta_query
Definition: regex:61
_Esc_uni
Definition: regex:91
_Esc_ctrl_v
Definition: regex:88
_Meta_cr
Definition: regex:75
_Meta_dlr
Definition: regex:56
_Esc_bsl
Definition: regex:79
_Esc_ctrl_f
Definition: regex:84
_Meta_esc
Definition: regex:65
_Meta_lsq
Definition: regex:62
_Meta_dot
Definition: regex:58
enum _Node_flags
Enumerator
_Fl_none 
_Fl_negate 
_Fl_greedy 
_Fl_final 
_Fl_longest 
1508  { // flags for nfa nodes with special properties
1509  _Fl_none = 0x00,
1510  _Fl_negate = 0x01,
1511  _Fl_greedy = 0x02,
1512  _Fl_final = 0x04,
1513  _Fl_longest = 0x08
1514  };
_Fl_none
Definition: regex:1509
_Fl_greedy
Definition: regex:1511
_Fl_longest
Definition: regex:1513
_Fl_negate
Definition: regex:1510
_Fl_final
Definition: regex:1512
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 
1532  { // type flag for nfa nodes
1533  _N_none,
1534  _N_nop,
1535  _N_bol,
1536  _N_eol,
1537  _N_wbound,
1538  _N_dot,
1539  _N_str,
1540  _N_class,
1541  _N_group,
1542  _N_end_group,
1543  _N_assert,
1544  _N_neg_assert,
1545  _N_end_assert,
1546  _N_capture,
1547  _N_end_capture,
1548  _N_back,
1549  _N_if,
1550  _N_endif,
1551  _N_rep,
1552  _N_end_rep,
1553  _N_begin,
1554  _N_end
1555  };
_N_str
Definition: regex:1539
_N_wbound
Definition: regex:1537
_N_dot
Definition: regex:1538
_N_end_assert
Definition: regex:1545
_N_end_rep
Definition: regex:1552
_N_group
Definition: regex:1541
_N_if
Definition: regex:1549
_N_neg_assert
Definition: regex:1544
_N_none
Definition: regex:1533
_N_end
Definition: regex:1554
_N_assert
Definition: regex:1543
_N_end_group
Definition: regex:1542
_N_eol
Definition: regex:1536
_N_rep
Definition: regex:1551
_N_begin
Definition: regex:1553
_N_end_capture
Definition: regex:1547
_N_back
Definition: regex:1548
_N_class
Definition: regex:1540
_N_endif
Definition: regex:1550
_N_nop
Definition: regex:1534
_N_bol
Definition: regex:1535
_N_capture
Definition: regex:1546
enum _Prs_ret
Enumerator
_Prs_none 
_Prs_chr 
_Prs_set 
2153  { // indicate class element type
2154  _Prs_none,
2155  _Prs_chr,
2156  _Prs_set
2157  };
_Prs_chr
Definition: regex:2155
_Prs_none
Definition: regex:2154
_Prs_set
Definition: regex:2156

Function Documentation

void _Calculate_loop_simplicity ( _Node_base *  _Nx,
_Node_base *  _Ne,
_Node_rep *  _Outer_rep 
)
inline
5651  { // walks regex NFA, calculates values of _Node_rep::_Simple_loop
5652  for (; _Nx != _Ne && _Nx != 0; _Nx = _Nx->_Next)
5653  {
5654  switch (_Nx->_Kind)
5655  {
5656  case _N_if:
5657  // _Node_if inside a _Node_rep makes the rep not simple
5658  if (_Outer_rep != 0)
5659  _Outer_rep->_Simple_loop = 0;
5660  // visit each branch of the if
5661  for (_Node_if *_Branch = static_cast<_Node_if *>(_Nx)->_Child;
5662  _Branch != 0;
5663  _Branch = _Branch->_Child)
5664  _Calculate_loop_simplicity(_Branch->_Next, _Branch->_Endif, _Outer_rep);
5665  break;
5666  case _N_assert:
5667  case _N_neg_assert:
5668  // visit the assertion body
5669  // note _Outer_rep being reset: the assertion regex is completely independent
5670  _Calculate_loop_simplicity(static_cast<_Node_assert *>(_Nx)->_Child, 0, 0);
5671  break;
5672  case _N_rep:
5673  // _Node_rep inside another _Node_rep makes both not simple
5674  if (_Outer_rep == 0)
5675  _Outer_rep = static_cast<_Node_rep *>(_Nx);
5676  else
5677  {
5678  _Outer_rep->_Simple_loop = 0;
5679  static_cast<_Node_rep *>(_Nx)->_Simple_loop = 0;
5680  }
5681  break;
5682  case _N_end_rep:
5683  if (_Outer_rep == static_cast<_Node_end_rep *>(_Nx)->_Begin_rep)
5684  {
5685  // if the _Node_rep is still undetermined when we reach its end, it is simple
5686 #pragma warning(push)
5687 #pragma warning(disable: 6011) // Dereferencing NULL pointer
5688  if (_Outer_rep->_Simple_loop == -1)
5689  _Outer_rep->_Simple_loop = 1;
5690 #pragma warning(pop)
5691  _Outer_rep = 0;
5692  }
5693  break;
5694  default:
5695  break;
5696  }
5697  }
5698  }
_Node_base::_Next
_Node_base * _Next
Definition: regex:1682
_N_end_rep
Definition: regex:1552
_Node_if
Definition: regex:1844
_N_if
Definition: regex:1549
_N_neg_assert
Definition: regex:1544
_N_assert
Definition: regex:1543
_Node_rep::_Simple_loop
int _Simple_loop
Definition: regex:1915
_N_rep
Definition: regex:1551
_Node_base::_Kind
_Node_type _Kind
Definition: regex:1680
_Calculate_loop_simplicity
void _Calculate_loop_simplicity(_Node_base *_Nx, _Node_base *_Ne, _Node_rep *_Outer_rep)
Definition: regex:5650
_Node_if::_Child
_Node_if * _Child
Definition: regex:1866
_Node_rep
Definition: regex:1896
template<class _BidIt1 , class _BidIt2 , class _Pr >
_BidIt1 _Cmp_chrange ( _BidIt1  _Begin1,
_BidIt1  _End1,
_BidIt2  _Begin2,
_BidIt2  _End2,
_Pr  _Pred 
)
inline
4337  { // compare character ranges
4338  _BidIt1 _Res = _Begin1;
4339  while (_Begin1 != _End1 && _Begin2 != _End2)
4340  if (!_Pred(*_Begin1++, *_Begin2++))
4341  return (_Res);
4342  return (_Begin2 == _End2 ? _Begin1 : _Res);
4343  }
cliext::_Pred
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
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 
)
inline
4351  { // compare character ranges
4352  _BidIt1 _Res = _End1;
4353  if (_Sflags & regex_constants::icase)
4354  _Res = _Cmp_chrange(_Begin1, _End1, _Begin2, _End2,
4355  _Cmp_icase<_RxTraits>(_Traits));
4356  else if (_Sflags & regex_constants::collate)
4357  _Res = _Cmp_chrange(_Begin1, _End1, _Begin2, _End2,
4358  _Cmp_collate<_RxTraits>(_Traits));
4359  else
4360  _Res = _Cmp_chrange(_Begin1, _End1, _Begin2, _End2,
4361  _Cmp_cs<_RxTraits>());
4362  return (_Res);
4363  }
_Cmp_icase
Definition: regex:196
_Cmp_collate
Definition: regex:218
_Cmp_chrange
_BidIt1 _Cmp_chrange(_BidIt1 _Begin1, _BidIt1 _End1, _BidIt2 _Begin2, _BidIt2 _End2, _Pr _Pred)
Definition: regex:4335
regex_constants::icase
Definition: regex:107
_Cmp_cs
Definition: regex:186
regex_constants::collate
Definition: regex:110
void _Destroy_node ( _Node_base *  _Nx,
_Node_base *  _Ne = 0 
)
inline
1693  { // destroy sublist of nodes
1694  while (_Nx != _Ne && _Nx != 0)
1695  { // destroy node
1696  _Node_base *_Tmp = _Nx;
1697  _Nx = _Nx->_Next;
1698  _Tmp->_Next = 0;
1699  delete _Tmp;
1700  }
1701  }
_Node_base::_Next
_Node_base * _Next
Definition: regex:1682
_Node_base
Definition: regex:1672
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
2628  { // format with ECMAScript rules
2629  while (_First != _Last)
2630  { // process one character or escape sequence
2631  if (*_First != '$')
2632  *_Out++ = *_First++;
2633  else if (++_First == _Last)
2634  *_Out++ = '$'; // preserve $ at end
2635  else if (*_First == '$')
2636  { // replace $$
2637  *_Out++ = '$';
2638  ++_First;
2639  }
2640  else if (*_First == '`')
2641  { // replace $`
2642  _Out = _Copy_no_deprecate(_Match.prefix().first,
2643  _Match.prefix().second, _Out);
2644  ++_First;
2645  }
2646  else if (*_First == '\'')
2647  { // replace $'
2648  _Out = _Copy_no_deprecate(_Match.suffix().first,
2649  _Match.suffix().second, _Out);
2650  ++_First;
2651  }
2652  else if (*_First == '&')
2653  { // replace $&
2654  ++_First;
2655  if (_Match.size() != 0)
2656  _Out = _Copy_no_deprecate(_Match._At(0).first,
2657  _Match._At(0).second, _Out);
2658  }
2659  else if (_Isdigit(*_First))
2660  { // replace capture group descriptors $n, $nn
2661  int n = *_First++ - '0';
2662  const bool _Two_digits = _First != _Last && _Isdigit(*_First);
2663  if (_Two_digits)
2664  { // process second digit
2665  n *= 10;
2666  n += *_First++ - '0';
2667  }
2668  if (n == 0)
2669  { // preserve $0, $00
2670  *_Out++ = '$';
2671  *_Out++ = '0';
2672  if (_Two_digits)
2673  *_Out++ = '0';
2674  }
2675  else if (n < (int)_Match.size())
2676  _Out = _Copy_no_deprecate(_Match._At(n).first,
2677  _Match._At(n).second, _Out);
2678  }
2679  else
2680  { // replace $x
2681  *_Out++ = '$';
2682  *_Out++ = *_First++;
2683  }
2684  }
2685  return (_Out);
2686  }
pair::second
_Ty2 second
Definition: utility:271
_Out
basic_ostream< _Elem, _Traits > & _Out(basic_ostream< _Elem, _Traits > &_Os, _Ty _Dx)
Definition: random:174
match_results::size
size_type size() const
Definition: regex:1254
match_results::suffix
const_reference suffix() const
Definition: regex:1294
_Copy_no_deprecate
_OutIt _Copy_no_deprecate(_InIt _First, _InIt _Last, _OutIt _Dest)
Definition: xutility:2334
_Isdigit
#define _Isdigit(x)
Definition: regex:2617
match_results::prefix
const_reference prefix() const
Definition: regex:1289
pair::first
_Ty1 first
Definition: utility:270
match_results::_At
_Elem & _At(unsigned int _Sub)
Definition: regex:1446
cliext::_Last
_FwdIt _Last
Definition: algorithm:1936
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
2696  { // format with sed rules
2697  while (_First != _Last)
2698  { // process one character or escape sequence
2699  if (*_First == '&')
2700  { // replace with full match
2701  ++_First;
2702  if (_Match.size() != 0)
2703  _Out = _Copy_no_deprecate(_Match._At(0).first,
2704  _Match._At(0).second, _Out);
2705  }
2706  else if (*_First != '\\')
2707  *_Out++ = *_First++;
2708  else if (++_First == _Last)
2709  ; // drop backslash at end
2710  else if (_Isdigit(*_First))
2711  { // replace \n, including \0
2712  int n = *_First++ - '0';
2713  if (n < (int)_Match.size())
2714  _Out = _Copy_no_deprecate(_Match._At(n).first,
2715  _Match._At(n).second, _Out);
2716  }
2717  else
2718  *_Out++ = *_First++; // replace \x, including \\, \&
2719  }
2720  return (_Out);
2721  }
pair::second
_Ty2 second
Definition: utility:271
_Out
basic_ostream< _Elem, _Traits > & _Out(basic_ostream< _Elem, _Traits > &_Os, _Ty _Dx)
Definition: random:174
match_results::size
size_type size() const
Definition: regex:1254
_Copy_no_deprecate
_OutIt _Copy_no_deprecate(_InIt _First, _InIt _Last, _OutIt _Dest)
Definition: xutility:2334
_Isdigit
#define _Isdigit(x)
Definition: regex:2617
pair::first
_Ty1 first
Definition: utility:270
match_results::_At
_Elem & _At(unsigned int _Sub)
Definition: regex:1446
cliext::_Last
_FwdIt _Last
Definition: algorithm:1936
bool _Is_word ( unsigned char  _UCh)
inline
611  { // test if _UCh is a word character
612  // special casing char to avoid branches for std::regex in this path
613  static constexpr bool _Is_word_table[(numeric_limits<unsigned char>::max)() + 1] =
614  {
615  /* X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 XA XB XC XD XE XF */
616  /* 0X */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
617  /* 1X */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
618  /* 2X */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
619  /* 3X */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, /* 0-9 */
620  /* 4X */ 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* A-Z */
621  /* 5X */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, /* 5F == _ */
622  /* 6X */ 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* a-z */
623  /* 7X */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0
624  /* non-ASCII values initialized to 0 */
625  };
626  return (_Is_word_table[_UCh]);
627  }
numeric_limits
Definition: limits:102
bool _Is_word ( char  _Ch)
inline
630  { // test if _Ch is a word character
631  return (_Is_word(static_cast<unsigned char>(_Ch)));
632  }
_Ch
_Check_return_ _In_ wchar_t _Ch
Definition: vcruntime_string.h:89
_Is_word
bool _Is_word(unsigned char _UCh)
Definition: regex:610
template<class _Elem >
bool _Is_word ( _Elem  _Ch)
inline
636  { // test if _Ch is a word character
637  // assumes 'x' == L'x' for the ASCII range
638  typedef make_unsigned_t<_Elem> _UElem;
639  const auto _UCh = static_cast<_UElem>(_Ch);
640  return (_UCh <= static_cast<_UElem>('z') && _Is_word(static_cast<unsigned char>(_UCh)));
641  }
_Ch
_Check_return_ _In_ wchar_t _Ch
Definition: vcruntime_string.h:89
_Is_word
bool _Is_word(unsigned char _UCh)
Definition: regex:610
make_unsigned_t
typename make_unsigned< _Ty >::type make_unsigned_t
Definition: type_traits:2072
template<class _Traits , class _FwdIt1 , class _FwdIt2 >
int _Iter_compare ( _FwdIt1  _First1,
_FwdIt1  _Last1,
_FwdIt2  _First2,
_FwdIt2  _Last2 
)
inline
590  { // compare two iterator ranges:
591  // if [_First1, _Last1) is lexicographically less than [_First2, _Last2)
592  // a negative value
593  // if [_First2, _Last2) is lexicographically less than [_First1, _Last1)
594  // a positive value
595  // otherwise
596  // zero
597  typedef typename _Traits::char_type _Elem;
598  static_assert(conjunction<
599  is_same<_Iter_value_t<_FwdIt1>, _Elem>,
600  is_same<_Iter_value_t<_FwdIt2>, _Elem>>::value,
601  "bad iterators to _Iter_compare");
602 
603  _DEBUG_RANGE(_First1, _Last1);
604  _DEBUG_RANGE(_First2, _Last2);
605  return (_Iter_compare2<_Traits>(_Unchecked(_First1), _Unchecked(_Last1),
606  _Unchecked(_First2), _Unchecked(_Last2)));
607  }
_DEBUG_RANGE
#define _DEBUG_RANGE(first, last)
Definition: xutility:902
cliext::_Unchecked
_Iter_t _Unchecked(_Iter_t _Iter)
Definition: iterator:11
_Iter_value_t
typename iterator_traits< _Iter >::value_type _Iter_value_t
Definition: xutility:649
is_same
Definition: xtr1common:87
conjunction
Definition: type_traits:1110
template<class _Traits , class _FwdIt1 , class _FwdIt2 >
int _Iter_compare2 ( _FwdIt1  _First1,
_FwdIt1  _Last1,
_FwdIt2  _First2,
_FwdIt2  _Last2 
)
inline
580  { // decide which _Iter_compare implementation to use
581  return (_Iter_compare3<_Traits>(_First1, _Last1, _First2, _Last2,
582  _Conjunction_t<is_pointer<_FwdIt1>, is_pointer<_FwdIt2>>{}));
583  }
_Conjunction_t
typename conjunction< _Traits...>::type _Conjunction_t
Definition: type_traits:1118
is_pointer
Definition: type_traits:366
template<class _Traits , class _FwdIt1 , class _FwdIt2 >
int _Iter_compare3 ( _FwdIt1  _First1,
_FwdIt1  _Last1,
_FwdIt2  _First2,
_FwdIt2  _Last2,
true_type   
)
inline
545  { // _Iter_compare for memory buffer ranges
546  return (_Traits_compare<_Traits>(_First1, _Last1 - _First1, _First2, _Last2 - _First2));
547  }
template<class _Traits , class _FwdIt1 , class _FwdIt2 >
int _Iter_compare3 ( _FwdIt1  _First1,
_FwdIt1  _Last1,
_FwdIt2  _First2,
_FwdIt2  _Last2,
false_type   
)
inline
554  { // _Iter_compare for general ranges
555  const pair<_FwdIt1, _FwdIt2> _Cmp = _STD mismatch(_First1, _Last1,
556  _First2, _Last2, _Char_traits_eq<_Traits>{});
557 
558  if (_Cmp.first == _Last1)
559  {
560  if (_Cmp.second == _Last2)
561  return (0);
562  else
563  return (-1);
564  }
565 
566  if (_Cmp.second == _Last2)
567  return (1);
568 
569  if (_Traits::lt(*_Cmp.first, *_Cmp.second))
570  return (-1);
571  else
572  return (1);
573  }
pair::second
_Ty2 second
Definition: utility:271
_Char_traits_eq
Definition: xutility:2268
pair::first
_Ty1 first
Definition: utility:270
mismatch
pair< _InIt1, _InIt2 > mismatch(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _Pr _Pred)
Definition: algorithm:267
pair
Definition: utility:92
_STD
template<class _BidIt , class _Elem >
_BidIt _Lookup_coll ( _BidIt  _First,
_BidIt  _Last,
const _Sequence< _Elem > *  _Eq 
)
inline
4405  { // look for collation element [_First, _Last) in _Eq
4406  while (_Eq)
4407  { // look for sequence of elements that are the right size
4408  for (unsigned int _Ix = 0; _Ix < _Eq->_Data._Size(); _Ix += _Eq->_Sz)
4409  { // look for character range
4410  _BidIt _Res = _First;
4411  for (size_t _Jx = 0; _Jx < _Eq->_Sz; ++_Jx)
4412  { // check current character
4413  if (*_Res++ != *(_Eq->_Data._Str() + _Ix + _Jx))
4414  break;
4415  }
4416  if (_Res == _Last)
4417  return (_Last);
4418  }
4419  _Eq = _Eq->_Next;
4420  }
4421  return (_First);
4422  }
_Sequence::_Data
_Buf< _Elem > _Data
Definition: regex:1667
_Sequence::_Next
_Sequence * _Next
Definition: regex:1668
_Sequence::_Sz
unsigned int _Sz
Definition: regex:1666
cliext::_Last
_FwdIt _Last
Definition: algorithm:1936
template<class _Elem , class _RxTraits >
bool _Lookup_equiv ( typename _RxTraits::_Uelem  _Ch,
const _Sequence< _Elem > *  _Eq,
const _RxTraits &  _Traits 
)
inline
4383  { // check whether _Ch is in _Eq
4384  typename _RxTraits::string_type _Str0;
4385  typename _RxTraits::string_type _Str1(1, _Ch);
4386  _Str1 = _Traits.transform_primary(_Str1.begin(), _Str1.end());
4387  while (_Eq)
4388  { // look for sequence of elements that are the right size
4389  for (unsigned int _Ix = 0; _Ix < _Eq->_Data._Size(); _Ix += _Eq->_Sz)
4390  { // look for _Ch
4391  _Str0.assign(_Eq->_Data._Str() + _Ix, _Eq->_Sz);
4392  _Str0 = _Traits.transform_primary(_Str0.begin(), _Str0.end());
4393  if (_Str0 == _Str1)
4394  return (true);
4395  }
4396  _Eq = _Eq->_Next;
4397  }
4398  return (false);
4399  }
_Sequence::_Data
_Buf< _Elem > _Data
Definition: regex:1667
_Sequence::_Next
_Sequence * _Next
Definition: regex:1668
_Ch
_Check_return_ _In_ wchar_t _Ch
Definition: vcruntime_string.h:89
_Sequence::_Sz
unsigned int _Sz
Definition: regex:1666
template<class _Elem >
bool _Lookup_range ( unsigned int  _Ch,
const _Buf< _Elem > *  _Bufptr 
)
inline
4367  { // check whether _Ch is in _Buf
4368  typedef typename make_unsigned<_Elem>::type _Uelem;
4369  for (unsigned int _Ix = 0; _Ix < _Bufptr->_Size(); _Ix += 2)
4370  { // check current position
4371  if ((_Uelem)_Bufptr->_At(_Ix) <= _Ch
4372  && _Ch <= (_Uelem)_Bufptr->_At(_Ix + 1))
4373  return (true);
4374  }
4375  return (false);
4376  }
_Buf::_Size
unsigned int _Size() const
Definition: regex:1571
_Ch
_Check_return_ _In_ wchar_t _Ch
Definition: vcruntime_string.h:89
_Buf::_At
_Elem _At(unsigned int _Idx) const
Definition: regex:1576
_List_iter_types
Definition: list:422
template<class _BidIt , class _Alloc , class _Elem , class _RxTraits , class _It >
bool _Regex_match1 ( _It  _First,
_It  _Last,
match_results< _BidIt, _Alloc > *  _Matches,
const basic_regex< _Elem, _RxTraits > &  _Re,
regex_constants::match_flag_type  _Flgs,
bool  _Full 
)
inline
2736  { // try to match regular expression to target text
2737  if (_Re._Empty())
2738  return (false);
2739  _Matcher<_BidIt, _Elem, _RxTraits, _It> _Mx(_First, _Last,
2740  _Re._Get_traits(), _Re._Get(), _Re.mark_count() + 1, _Re.flags(),
2741  _Flgs);
2742  return (_Mx._Match(_Matches, _Full));
2743  }
basic_regex::mark_count
unsigned int mark_count() const
Definition: regex:2456
basic_regex::flags
flag_type flags() const
Definition: regex:2505
basic_regex::_Empty
bool _Empty() const
Definition: regex:2535
basic_regex::_Get
_Root_node * _Get() const
Definition: regex:2530
basic_regex::_Get_traits
const _RxTraits & _Get_traits() const
Definition: regex:2540
cliext::_Last
_FwdIt _Last
Definition: algorithm:1936
_Matcher
Definition: regex:2021
template<class _OutIt , class _BidIt , class _RxTraits , class _Elem , class _Traits , class _Alloc >
_OutIt _Regex_replace1 ( _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
3014  { // search and replace
3015  match_results<_BidIt> _Matches;
3016  _BidIt _Pos = _First;
3017  regex_constants::match_flag_type _Flags = _Flgs;
3018  regex_constants::match_flag_type _Not_null =
3019  (regex_constants::match_flag_type)0;
3020 
3021  while (_Regex_search1(_Pos, _Last, &_Matches, _Re, _Flags | _Not_null, _Pos))
3022  { // replace at each match
3023  if (!(_Flgs & regex_constants::format_no_copy))
3024  _Result = _Copy_no_deprecate(_Matches.prefix().first,
3025  _Matches.prefix().second, _Result);
3026  _Result = _Matches._Format1(_Result,
3027  _Unchecked(_Fmt.begin()), _Unchecked(_Fmt.end()), _Flags);
3028 
3029  _Pos = _Matches[0].second;
3030  if (_Pos == _Last
3031  || _Flgs & regex_constants::format_first_only)
3032  break;
3033 
3034  if (_Matches[0].first == _Matches[0].second)
3035  _Not_null = regex_constants::_Match_not_null;
3036  else
3037  { // non-null match, recognize earlier text
3038  _Not_null = (regex_constants::match_flag_type)0;
3039  _Flags |= regex_constants::match_prev_avail;
3040  }
3041  }
3042  return (_Flgs & regex_constants::format_no_copy
3043  ? _Result : _Copy_no_deprecate(_Pos, _Last, _Result));
3044  }
pair::second
_Ty2 second
Definition: utility:271
_Copy_no_deprecate
_OutIt _Copy_no_deprecate(_InIt _First, _InIt _Last, _OutIt _Dest)
Definition: xutility:2334
_Regex_search1
bool _Regex_search1(_It _First, _It _Last, match_results< _BidIt, _Alloc > *_Matches, const basic_regex< _Elem, _RxTraits > &_Re, regex_constants::match_flag_type _Flgs, _It _Org)
Definition: regex:2855
regex_constants::_Match_not_null
Definition: regex:130
regex_constants::match_flag_type
match_flag_type
Definition: regex:115
match_results::prefix
const_reference prefix() const
Definition: regex:1289
match_results< _BidIt >
pair::first
_Ty1 first
Definition: utility:270
regex_constants::format_no_copy
Definition: regex:128
basic_string::end
iterator end() _NOEXCEPT
Definition: xstring:2869
cliext::_Unchecked
_Iter_t _Unchecked(_Iter_t _Iter)
Definition: iterator:11
match_results::_Format1
_OutIt _Format1(_OutIt _Out, const char_type *_Fmt_begin, const char_type *_Fmt_end, regex_constants::match_flag_type _Flags) const
Definition: regex:1320
basic_string::begin
iterator begin() _NOEXCEPT
Definition: xstring:2857
regex_constants::match_prev_avail
Definition: regex:125
_Result
_Result
Definition: corecrt_wconio.h:362
cliext::_Last
_FwdIt _Last
Definition: algorithm:1936
regex_constants::format_first_only
Definition: regex:129
template<class _BidIt , class _Alloc , class _Elem , class _RxTraits , class _It >
bool _Regex_search1 ( _It  _First,
_It  _Last,
match_results< _BidIt, _Alloc > *  _Matches,
const basic_regex< _Elem, _RxTraits > &  _Re,
regex_constants::match_flag_type  _Flgs,
_It  _Org 
)
inline
2860  { // search for regular expression match in target text
2861  if (_Re._Empty())
2862  return (false);
2863  bool _Found = false;
2864  _It _Begin = _First;
2865  _Matcher<_BidIt, _Elem, _RxTraits, _It> _Mx(_First, _Last,
2866  _Re._Get_traits(), _Re._Get(), _Re.mark_count() + 1, _Re.flags(),
2867  _Flgs);
2868 
2869  if (_Mx._Match(_Matches, false))
2870  _Found = true;
2871  else if (_First == _Last
2872  || _Flgs & regex_constants::match_continuous)
2873  ;
2874  else
2875  { // try more on suffixes
2876  _Mx._Setf(regex_constants::match_prev_avail);
2877  _Mx._Clearf(regex_constants::_Match_not_null);
2878  while ((_First = _Mx._Skip(++_First, _Last)) != _Last)
2879  if (_Mx._Match(_First, _Matches, false))
2880  { // found match starting at _First
2881  _Found = true;
2882  break;
2883  }
2884  if (!_Found && _Mx._Match(_Last, _Matches, false))
2885  _Found = true;
2886  }
2887  if (_Found && _Matches)
2888  { // update _Matches
2889  _Matches->_Org = _Org;
2890  _Matches->_Pfx().first = _Begin;
2891  _Matches->_Pfx().matched =
2892  _Matches->_Pfx().first != _Matches->_Pfx().second;
2893  }
2894  return (_Found);
2895  }
pair::second
_Ty2 second
Definition: utility:271
regex_constants::match_continuous
Definition: regex:124
match_results::_Org
_BidIt _Org
Definition: regex:1456
basic_regex::mark_count
unsigned int mark_count() const
Definition: regex:2456
sub_match::matched
bool matched
Definition: regex:664
basic_regex::flags
flag_type flags() const
Definition: regex:2505
regex_constants::_Match_not_null
Definition: regex:130
pair::first
_Ty1 first
Definition: utility:270
_Matcher::_Setf
void _Setf(regex_constants::match_flag_type _Mf)
Definition: regex:2038
match_results::_Pfx
_Elem & _Pfx()
Definition: regex:1431
basic_regex::_Empty
bool _Empty() const
Definition: regex:2535
basic_regex::_Get
_Root_node * _Get() const
Definition: regex:2530
regex_constants::match_prev_avail
Definition: regex:125
basic_regex::_Get_traits
const _RxTraits & _Get_traits() const
Definition: regex:2540
cliext::_Last
_FwdIt _Last
Definition: algorithm:1936
_Matcher
Definition: regex:2021
_CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL _Xregex_error ( regex_constants::error_type  _Code)
template<class _BidIt >
bool operator!= ( const sub_match< _BidIt > &  _Left,
const sub_match< _BidIt > &  _Right 
)
inline
788  { // test for inequality
789  return (!(_Left == _Right));
790  }
template<class _BidIt >
bool operator!= ( const _Iter_value_t< _BidIt > *  _Left,
const sub_match< _BidIt > &  _Right 
)
inline
837  { // test for inequality
838  return (!(_Left == _Right));
839  }
_Left
constexpr const _Ty &() _Left
Definition: algorithm:3722
template<class _BidIt >
bool operator!= ( const sub_match< _BidIt > &  _Left,
const _Iter_value_t< _BidIt > *  _Right 
)
inline
885  { // test for inequality
886  return (!(_Left == _Right));
887  }
_Right
constexpr const _Ty &() _Right
Definition: algorithm:3723
template<class _BidIt >
bool operator!= ( const _Iter_value_t< _BidIt > &  _Left,
const sub_match< _BidIt > &  _Right 
)
inline
934  { // test for inequality
935  return (!(_Left == _Right));
936  }
_Left
constexpr const _Ty &() _Left
Definition: algorithm:3722
template<class _BidIt >
bool operator!= ( const sub_match< _BidIt > &  _Left,
const _Iter_value_t< _BidIt > &  _Right 
)
inline
982  { // test for inequality
983  return (!(_Left == _Right));
984  }
_Right
constexpr const _Ty &() _Right
Definition: algorithm:3723
template<class _BidIt , class _Traits , class _Alloc >
bool operator!= ( const sub_match< _BidIt > &  _Left,
const basic_string< _Iter_value_t< _BidIt >, _Traits, _Alloc > &  _Right 
)
inline
1035  { // test for inequality
1036  return (!(_Left == _Right));
1037  }
template<class _BidIt , class _Traits , class _Alloc >
bool operator!= ( const basic_string< _Iter_value_t< _BidIt >, _Traits, _Alloc > &  _Left,
const sub_match< _BidIt > &  _Right 
)
inline
1095  { // test for inequality
1096  return (!(_Left == _Right));
1097  }
template<class _BidIt , class _Alloc >
bool operator!= ( const match_results< _BidIt, _Alloc > &  _Left,
const match_results< _BidIt, _Alloc > &  _Right 
)
1491  { // compare results for inequality
1492  return (!(_Left == _Right));
1493  }
template<class _BidIt >
bool operator< ( const sub_match< _BidIt > &  _Left,
const sub_match< _BidIt > &  _Right 
)
inline
796  { // test if _Left < _Right
797  return (_Left._Less(_Right));
798  }
sub_match::_Less
bool _Less(const sub_match &_Right) const
Definition: regex:728
template<class _BidIt >
bool operator< ( const _Iter_value_t< _BidIt > *  _Left,
const sub_match< _BidIt > &  _Right 
)
inline
845  { // test if _Left < _Right
846  return (_Right._Greater(_Left));
847  }
_Left
constexpr const _Ty &() _Left
Definition: algorithm:3722
sub_match::_Greater
bool _Greater(const value_type *const _Ptr, const _Size_type _Count) const
Definition: regex:748
template<class _BidIt >
bool operator< ( const sub_match< _BidIt > &  _Left,
const _Iter_value_t< _BidIt > *  _Right 
)
inline
893  { // test if _Left < _Right
894  return (_Left._Less(_Right));
895  }
sub_match::_Less
bool _Less(const sub_match &_Right) const
Definition: regex:728
_Right
constexpr const _Ty &() _Right
Definition: algorithm:3723
template<class _BidIt >
bool operator< ( const _Iter_value_t< _BidIt > &  _Left,
const sub_match< _BidIt > &  _Right 
)
inline
942  { // test if _Left < _Right
943  return (_Right._Greater(&_Left, 1));
944  }
_Left
constexpr const _Ty &() _Left
Definition: algorithm:3722
sub_match::_Greater
bool _Greater(const value_type *const _Ptr, const _Size_type _Count) const
Definition: regex:748
template<class _BidIt >
bool operator< ( const sub_match< _BidIt > &  _Left,
const _Iter_value_t< _BidIt > &  _Right 
)
inline
990  { // test if _Left < _Right
991  return (_Left._Less(&_Right, 1));
992  }
sub_match::_Less
bool _Less(const sub_match &_Right) const
Definition: regex:728
_Right
constexpr const _Ty &() _Right
Definition: algorithm:3723
template<class _BidIt , class _Traits , class _Alloc >
bool operator< ( const sub_match< _BidIt > &  _Left,
const basic_string< _Iter_value_t< _BidIt >, _Traits, _Alloc > &  _Right 
)
inline
1045  { // test if _Left < _Right
1046  return (_Left._Less(_Right.data(), _Right.size()));
1047  }
basic_string::data
_Ret_z_ const _Elem * data() const _NOEXCEPT
Definition: xstring:3006
sub_match::_Less
bool _Less(const sub_match &_Right) const
Definition: regex:728
basic_string::size
size_type size() const _NOEXCEPT
Definition: xstring:3023
template<class _BidIt , class _Traits , class _Alloc >
bool operator< ( const basic_string< _Iter_value_t< _BidIt >, _Traits, _Alloc > &  _Left,
const sub_match< _BidIt > &  _Right 
)
inline
1105  { // test if _Left < _Right
1106  return (_Right._Greater(_Left.data(), _Left.size()));
1107  }
basic_string::data
_Ret_z_ const _Elem * data() const _NOEXCEPT
Definition: xstring:3006
basic_string::size
size_type size() const _NOEXCEPT
Definition: xstring:3023
sub_match::_Greater
bool _Greater(const value_type *const _Ptr, const _Size_type _Count) const
Definition: regex:748
template<class _Elem , class _Traits , class _BidIt >
basic_ostream<_Elem, _Traits>& operator<< ( basic_ostream< _Elem, _Traits > &  _Ostr,
const sub_match< _BidIt > &  _Match 
)
1146  { // insert into basic_ostream
1147  return (_Ostr << _Match.str());
1148  }
sub_match::str
string_type str() const
Definition: regex:677
template<class _BidIt >
bool operator<= ( const sub_match< _BidIt > &  _Left,
const sub_match< _BidIt > &  _Right 
)
inline
812  { // test if _Left <= _Right
813  return (!(_Right < _Left));
814  }
template<class _BidIt >
bool operator<= ( const _Iter_value_t< _BidIt > *  _Left,
const sub_match< _BidIt > &  _Right 
)
inline
861  { // test if _Left <= _Right
862  return (!(_Right < _Left));
863  }
_Left
constexpr const _Ty &() _Left
Definition: algorithm:3722
template<class _BidIt >
bool operator<= ( const sub_match< _BidIt > &  _Left,
const _Iter_value_t< _BidIt > *  _Right 
)
inline
909  { // test if _Left <= _Right
910  return (!(_Right < _Left));
911  }
_Right
constexpr const _Ty &() _Right
Definition: algorithm:3723
template<class _BidIt >
bool operator<= ( const _Iter_value_t< _BidIt > &  _Left,
const sub_match< _BidIt > &  _Right 
)
inline
958  { // test if _Left <= _Right
959  return (!(_Right < _Left));
960  }
_Left
constexpr const _Ty &() _Left
Definition: algorithm:3722
template<class _BidIt >
bool operator<= ( const sub_match< _BidIt > &  _Left,
const _Iter_value_t< _BidIt > &  _Right 
)
inline
1006  { // test if _Left <= _Right
1007  return (!(_Right < _Left));
1008  }
_Right
constexpr const _Ty &() _Right
Definition: algorithm:3723
template<class _BidIt , class _Traits , class _Alloc >
bool operator<= ( const sub_match< _BidIt > &  _Left,
const basic_string< _Iter_value_t< _BidIt >, _Traits, _Alloc > &  _Right 
)
inline
1065  { // test if _Left <= _Right
1066  return (!(_Right < _Left));
1067  }
template<class _BidIt , class _Traits , class _Alloc >
bool operator<= ( const basic_string< _Iter_value_t< _BidIt >, _Traits, _Alloc > &  _Left,
const sub_match< _BidIt > &  _Right 
)
inline
1125  { // test if _Left <= _Right
1126  return (!(_Right < _Left));
1127  }
template<class _BidIt >
bool operator== ( const sub_match< _BidIt > &  _Left,
const sub_match< _BidIt > &  _Right 
)
inline
780  { // test for equality
781  return (_Left._Match_equal(_Right));
782  }
sub_match::_Match_equal
bool _Match_equal(const sub_match &_Right) const
Definition: regex:708
template<class _BidIt >
bool operator== ( const _Iter_value_t< _BidIt > *  _Left,
const sub_match< _BidIt > &  _Right 
)
inline
829  { // test for equality
830  return (_Right._Match_equal(_Left));
831  }
_Left
constexpr const _Ty &() _Left
Definition: algorithm:3722
sub_match::_Match_equal
bool _Match_equal(const sub_match &_Right) const
Definition: regex:708
template<class _BidIt >
bool operator== ( const sub_match< _BidIt > &  _Left,
const _Iter_value_t< _BidIt > *  _Right 
)
inline
877  { // test for equality
878  return (_Left._Match_equal(_Right));
879  }
sub_match::_Match_equal
bool _Match_equal(const sub_match &_Right) const
Definition: regex:708
_Right
constexpr const _Ty &() _Right
Definition: algorithm:3723
template<class _BidIt >
bool operator== ( const _Iter_value_t< _BidIt > &  _Left,
const sub_match< _BidIt > &  _Right 
)
inline
926  { // test for equality
927  return (_Right._Match_equal(&_Left, 1));
928  }
_Left
constexpr const _Ty &() _Left
Definition: algorithm:3722
sub_match::_Match_equal
bool _Match_equal(const sub_match &_Right) const
Definition: regex:708
template<class _BidIt >
bool operator== ( const sub_match< _BidIt > &  _Left,
const _Iter_value_t< _BidIt > &  _Right 
)
inline
974  { // test for equality
975  return (_Left._Match_equal(&_Right, 1));
976  }
sub_match::_Match_equal
bool _Match_equal(const sub_match &_Right) const
Definition: regex:708
_Right
constexpr const _Ty &() _Right
Definition: algorithm:3723
template<class _BidIt , class _Traits , class _Alloc >
bool operator== ( const sub_match< _BidIt > &  _Left,
const basic_string< _Iter_value_t< _BidIt >, _Traits, _Alloc > &  _Right 
)
inline
1025  { // test for equality
1026  return (_Left._Match_equal(_Right.data(), _Right.size()));
1027  }
basic_string::data
_Ret_z_ const _Elem * data() const _NOEXCEPT
Definition: xstring:3006
basic_string::size
size_type size() const _NOEXCEPT
Definition: xstring:3023
sub_match::_Match_equal
bool _Match_equal(const sub_match &_Right) const
Definition: regex:708
template<class _BidIt , class _Traits , class _Alloc >
bool operator== ( const basic_string< _Iter_value_t< _BidIt >, _Traits, _Alloc > &  _Left,
const sub_match< _BidIt > &  _Right 
)
inline
1085  { // test for equality
1086  return (_Right._Match_equal(_Left.data(), _Left.size()));
1087  }
basic_string::data
_Ret_z_ const _Elem * data() const _NOEXCEPT
Definition: xstring:3006
basic_string::size
size_type size() const _NOEXCEPT
Definition: xstring:3023
sub_match::_Match_equal
bool _Match_equal(const sub_match &_Right) const
Definition: regex:708
template<class _BidIt , class _Alloc >
bool operator== ( const match_results< _BidIt, _Alloc > &  _Left,
const match_results< _BidIt, _Alloc > &  _Right 
)
1471  { // compare results for equality
1472  if (!_Left.ready() && !_Right.ready())
1473  return (true);
1474  else if (!_Left.ready() || !_Right.ready())
1475  return (false);
1476  else if (_Left.empty() && _Right.empty())
1477  return (true);
1478  else if (_Left.empty() || _Right.empty())
1479  return (false);
1480  else
1481  return (_Left.size() == _Right.size()
1482  && _Left.prefix() == _Right.prefix()
1483  && _Left.suffix() == _Right.suffix()
1484  && _STD equal(_Left.begin(), _Left.end(), _Right.begin()));
1485  }
match_results::size
size_type size() const
Definition: regex:1254
match_results::empty
bool empty() const
Definition: regex:1264
match_results::suffix
const_reference suffix() const
Definition: regex:1294
match_results::end
const_iterator end() const
Definition: regex:1304
match_results::prefix
const_reference prefix() const
Definition: regex:1289
match_results::ready
bool ready() const
Definition: regex:1249
match_results::begin
const_iterator begin() const
Definition: regex:1299
cliext::equal
bool equal(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2)
Definition: memory:611
_STD
template<class _BidIt >
bool operator> ( const sub_match< _BidIt > &  _Left,
const sub_match< _BidIt > &  _Right 
)
inline
804  { // test if _Left > _Right
805  return (_Right < _Left);
806  }
template<class _BidIt >
bool operator> ( const _Iter_value_t< _BidIt > *  _Left,
const sub_match< _BidIt > &  _Right 
)
inline
853  { // test if _Left > _Right
854  return (_Right < _Left);
855  }
_Left
constexpr const _Ty &() _Left
Definition: algorithm:3722
template<class _BidIt >
bool operator> ( const sub_match< _BidIt > &  _Left,
const _Iter_value_t< _BidIt > *  _Right 
)
inline
901  { // test if _Left > _Right
902  return (_Right < _Left);
903  }
_Right
constexpr const _Ty &() _Right
Definition: algorithm:3723
template<class _BidIt >
bool operator> ( const _Iter_value_t< _BidIt > &  _Left,
const sub_match< _BidIt > &  _Right 
)
inline
950  { // test if _Left > _Right
951  return (_Right < _Left);
952  }
_Left
constexpr const _Ty &() _Left
Definition: algorithm:3722
template<class _BidIt >
bool operator> ( const sub_match< _BidIt > &  _Left,
const _Iter_value_t< _BidIt > &  _Right 
)
inline
998  { // test if _Left > _Right
999  return (_Right < _Left);
1000  }
_Right
constexpr const _Ty &() _Right
Definition: algorithm:3723
template<class _BidIt , class _Traits , class _Alloc >
bool operator> ( const sub_match< _BidIt > &  _Left,
const basic_string< _Iter_value_t< _BidIt >, _Traits, _Alloc > &  _Right 
)
inline
1055  { // test if _Left > _Right
1056  return (_Right < _Left);
1057  }
template<class _BidIt , class _Traits , class _Alloc >
bool operator> ( const basic_string< _Iter_value_t< _BidIt >, _Traits, _Alloc > &  _Left,
const sub_match< _BidIt > &  _Right 
)
inline
1115  { // test if _Left > _Right
1116  return (_Right < _Left);
1117  }
template<class _BidIt >
bool operator>= ( const sub_match< _BidIt > &  _Left,
const sub_match< _BidIt > &  _Right 
)
inline
820  { // test if _Left >= _Right
821  return (!(_Left < _Right));
822  }
template<class _BidIt >
bool operator>= ( const _Iter_value_t< _BidIt > *  _Left,
const sub_match< _BidIt > &  _Right 
)
inline
869  { // test if _Left >= _Right
870  return (!(_Left < _Right));
871  }
_Left
constexpr const _Ty &() _Left
Definition: algorithm:3722
template<class _BidIt >
bool operator>= ( const sub_match< _BidIt > &  _Left,
const _Iter_value_t< _BidIt > *  _Right 
)
inline
917  { // test if _Left >= _Right
918  return (!(_Left < _Right));
919  }
_Right
constexpr const _Ty &() _Right
Definition: algorithm:3723
template<class _BidIt >
bool operator>= ( const _Iter_value_t< _BidIt > &  _Left,
const sub_match< _BidIt > &  _Right 
)
inline
966  { // test if _Left >= _Right
967  return (!(_Left < _Right));
968  }
_Left
constexpr const _Ty &() _Left
Definition: algorithm:3722
template<class _BidIt >
bool operator>= ( const sub_match< _BidIt > &  _Left,
const _Iter_value_t< _BidIt > &  _Right 
)
inline
1014  { // test if _Left >= _Right
1015  return (!(_Left < _Right));
1016  }
_Right
constexpr const _Ty &() _Right
Definition: algorithm:3723
template<class _BidIt , class _Traits , class _Alloc >
bool operator>= ( const sub_match< _BidIt > &  _Left,
const basic_string< _Iter_value_t< _BidIt >, _Traits, _Alloc > &  _Right 
)
inline
1075  { // test if _Left >= _Right
1076  return (!(_Left < _Right));
1077  }
template<class _BidIt , class _Traits , class _Alloc >
bool operator>= ( const basic_string< _Iter_value_t< _BidIt >, _Traits, _Alloc > &  _Left,
const sub_match< _BidIt > &  _Right 
)
inline
1135  { // test if _Left >= _Right
1136  return (!(_Left < _Right));
1137  }
_Node_flags operator^= ( _Node_flags &  _Left,
_Node_flags  _Right 
)
inline
1527  { // bitwise xor
1528  return (_Left = _Node_flags((int)_Left ^ _Right));
1529  }
_Left
constexpr const _Ty &() _Left
Definition: algorithm:3722
_Node_flags
_Node_flags
Definition: regex:1507
_Right
constexpr const _Ty &() _Right
Definition: algorithm:3723
_Node_flags operator| ( _Node_flags  _Left,
_Node_flags  _Right 
)
inline
1517  { // bitwise or
1518  return (_Node_flags((int)_Left | _Right));
1519  }
_Left
constexpr const _Ty &() _Left
Definition: algorithm:3722
_Node_flags
_Node_flags
Definition: regex:1507
_Right
constexpr const _Ty &() _Right
Definition: algorithm:3723
_Node_flags operator|= ( _Node_flags &  _Left,
_Node_flags  _Right 
)
inline
1522  { // bitwise or
1523  return (_Left = _Node_flags((int)_Left | _Right));
1524  }
_Left
constexpr const _Ty &() _Left
Definition: algorithm:3722
_Node_flags
_Node_flags
Definition: regex:1507
_Right
constexpr const _Ty &() _Right
Definition: algorithm:3723
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
2755  { // try to match regular expression to target text
2756  _DEBUG_RANGE(_First, _Last);
2757  return (_Regex_match1(_First, _Last,
2758  &_Matches, _Re, _Flgs, true));
2759  }
_DEBUG_RANGE
#define _DEBUG_RANGE(first, last)
Definition: xutility:902
_Regex_match1
bool _Regex_match1(_It _First, _It _Last, match_results< _BidIt, _Alloc > *_Matches, const basic_regex< _Elem, _RxTraits > &_Re, regex_constants::match_flag_type _Flgs, bool _Full)
Definition: regex:2731
cliext::_Last
_FwdIt _Last
Definition: algorithm:1936
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
2768  { // try to match regular expression to target text
2769  _DEBUG_RANGE(_First, _Last);
2770  return (_Regex_match1(_Unchecked(_First), _Unchecked(_Last),
2771  static_cast<match_results<decltype(_Unchecked(_First))> *>(0), _Re,
2772  _Flgs | regex_constants::match_any, true));
2773  }
_DEBUG_RANGE
#define _DEBUG_RANGE(first, last)
Definition: xutility:902
regex_constants::match_any
Definition: regex:122
match_results
Definition: regex:1153
_Regex_match1
bool _Regex_match1(_It _First, _It _Last, match_results< _BidIt, _Alloc > *_Matches, const basic_regex< _Elem, _RxTraits > &_Re, regex_constants::match_flag_type _Flgs, bool _Full)
Definition: regex:2731
cliext::_Unchecked
_Iter_t _Unchecked(_Iter_t _Iter)
Definition: iterator:11
cliext::_Last
_FwdIt _Last
Definition: algorithm:1936
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
2781  { // try to match regular expression to target text
2782  const _Elem *_Last = _Str + char_traits<_Elem>::length(_Str);
2783  return (_Regex_match1(_Str, _Last,
2784  static_cast<match_results<const _Elem *> *>(0), _Re,
2785  _Flgs | regex_constants::match_any, true));
2786  }
regex_constants::match_any
Definition: regex:122
match_results
Definition: regex:1153
_Char_traits< _Elem, long >::length
static size_t __CLRCALL_OR_CDECL length(_In_z_ const _Elem *_First) _NOEXCEPT
Definition: iosfwd:148
_Regex_match1
bool _Regex_match1(_It _First, _It _Last, match_results< _BidIt, _Alloc > *_Matches, const basic_regex< _Elem, _RxTraits > &_Re, regex_constants::match_flag_type _Flgs, bool _Full)
Definition: regex:2731
cliext::_Last
_FwdIt _Last
Definition: algorithm:1936
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
2796  { // try to match regular expression to target text
2797  const _Elem *_Last = _Str + char_traits<_Elem>::length(_Str);
2798  return (_Regex_match1(_Str, _Last,
2799  &_Matches, _Re, _Flgs, true));
2800  }
_Char_traits< _Elem, long >::length
static size_t __CLRCALL_OR_CDECL length(_In_z_ const _Elem *_First) _NOEXCEPT
Definition: iosfwd:148
_Regex_match1
bool _Regex_match1(_It _First, _It _Last, match_results< _BidIt, _Alloc > *_Matches, const basic_regex< _Elem, _RxTraits > &_Re, regex_constants::match_flag_type _Flgs, bool _Full)
Definition: regex:2731
cliext::_Last
_FwdIt _Last
Definition: algorithm:1936
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
2814  { // try to match regular expression to target text
2815  return (_Regex_match1(_Str.begin(), _Str.end(),
2816  &_Matches, _Re, _Flgs, true));
2817  }
_Regex_match1
bool _Regex_match1(_It _First, _It _Last, match_results< _BidIt, _Alloc > *_Matches, const basic_regex< _Elem, _RxTraits > &_Re, regex_constants::match_flag_type _Flgs, bool _Full)
Definition: regex:2731
basic_string::end
iterator end() _NOEXCEPT
Definition: xstring:2869
basic_string::begin
iterator begin() _NOEXCEPT
Definition: xstring:2857
template<class _StTraits , class _StAlloc , class _Alloc , class _Elem , class _RxTraits >
bool regex_match ( const basic_string< _Elem, _StTraits, _StAlloc > &&  ,
match_results< typename basic_string< _Elem, _StTraits, _StAlloc >::const_iterator, _Alloc > &  ,
const basic_regex< _Elem, _RxTraits > &  ,
regex_constants::match_flag_type  = regex_constants::match_default 
)
delete
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
2841  { // try to match regular expression to target text
2842  typedef typename basic_string<_Elem, _StTraits, _StAlloc>
2843  ::const_iterator _Iter;
2844  return (_Regex_match1(_Unchecked(_Str.begin()), _Unchecked(_Str.end()),
2845  static_cast<match_results<decltype(_Unchecked(_Str.begin()))> *>(0), _Re,
2846  _Flgs | regex_constants::match_any, true));
2847  }
regex_constants::match_any
Definition: regex:122
match_results
Definition: regex:1153
experimental::filesystem::v1::begin
const directory_iterator & begin(const directory_iterator &_Iter) _NOEXCEPT
Definition: filesystem:1960
_Regex_match1
bool _Regex_match1(_It _First, _It _Last, match_results< _BidIt, _Alloc > *_Matches, const basic_regex< _Elem, _RxTraits > &_Re, regex_constants::match_flag_type _Flgs, bool _Full)
Definition: regex:2731
basic_string::end
iterator end() _NOEXCEPT
Definition: xstring:2869
cliext::_Unchecked
_Iter_t _Unchecked(_Iter_t _Iter)
Definition: iterator:11
basic_string::begin
iterator begin() _NOEXCEPT
Definition: xstring:2857
basic_string
Definition: xstring:1866
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
3058  { // search and replace, iterator result, string format
3059  _DEPRECATE_UNCHECKED(regex_replace, _Result);
3060  _DEBUG_RANGE(_First, _Last);
3061  return (_Rechecked(_Result,
3062  _Regex_replace1(_Unchecked_idl0(_Result), _Unchecked(_First), _Unchecked(_Last),
3063  _Re, _Fmt, _Flgs)));
3064  }
_DEPRECATE_UNCHECKED
#define _DEPRECATE_UNCHECKED(_Func, _Iter)
Definition: xutility:501
_DEBUG_RANGE
#define _DEBUG_RANGE(first, last)
Definition: xutility:902
_Rechecked
_Deque_const_iterator< _Mydeque > & _Rechecked(_Deque_const_iterator< _Mydeque > &_Iter, typename _Deque_const_iterator< _Mydeque >::_Unchecked_type _Right)
Definition: deque:527
_Regex_replace1
_OutIt _Regex_replace1(_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)
Definition: regex:3009
cliext::_Unchecked
_Iter_t _Unchecked(_Iter_t _Iter)
Definition: iterator:11
regex_replace
_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)
Definition: regex:3052
_Result
_Result
Definition: corecrt_wconio.h:362
cliext::_Last
_FwdIt _Last
Definition: algorithm:1936
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
3097  { // search and replace, iterator result, NTBS format
3098  const basic_string<_Elem> _Fmt(_Ptr);
3099  return (_STD regex_replace(_Result,
3100  _First, _Last, _Re, _Fmt, _Flgs));
3101  }
regex_replace
_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)
Definition: regex:3052
basic_string
Definition: xstring:1866
_Result
_Result
Definition: corecrt_wconio.h:362
_STD
cliext::_Last
_FwdIt _Last
Definition: algorithm:1936
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 
)
3134  { // search and replace, string result, string target, string format
3135  basic_string<_Elem, _Traits1, _Alloc1> _Res;
3136  _STD regex_replace(_STD back_inserter(_Res), _Str.begin(), _Str.end(),
3137  _Re, _Fmt, _Flgs);
3138  return (_Res);
3139  }
back_inserter
back_insert_iterator< _Container > back_inserter(_Container &_Cont)
Definition: xutility:3750
basic_string::end
iterator end() _NOEXCEPT
Definition: xstring:2869
basic_string::begin
iterator begin() _NOEXCEPT
Definition: xstring:2857
regex_replace
_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)
Definition: regex:3052
basic_string
Definition: xstring:1866
_STD
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 
)
3151  { // search and replace, string result, string target, NTBS format
3152  basic_string<_Elem, _Traits1, _Alloc1> _Res;
3153  const basic_string<_Elem> _Fmt(_Ptr);
3154  _STD regex_replace(_STD back_inserter(_Res), _Str.begin(), _Str.end(),
3155  _Re, _Fmt, _Flgs);
3156  return (_Res);
3157  }
back_inserter
back_insert_iterator< _Container > back_inserter(_Container &_Cont)
Definition: xutility:3750
basic_string::end
iterator end() _NOEXCEPT
Definition: xstring:2869
basic_string::begin
iterator begin() _NOEXCEPT
Definition: xstring:2857
regex_replace
_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)
Definition: regex:3052
basic_string
Definition: xstring:1866
_STD
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 
)
3169  { // search and replace, string result, NTBS target, string format
3170  basic_string<_Elem> _Res;
3171  const basic_string<_Elem> _Str(_Pstr);
3172  _STD regex_replace(_STD back_inserter(_Res), _Str.begin(), _Str.end(),
3173  _Re, _Fmt, _Flgs);
3174  return (_Res);
3175  }
back_inserter
back_insert_iterator< _Container > back_inserter(_Container &_Cont)
Definition: xutility:3750
regex_replace
_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)
Definition: regex:3052
basic_string
Definition: xstring:1866
_STD
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 
)
3185  { // search and replace, string result, NTBS target, NTBS format
3186  basic_string<_Elem> _Res;
3187  const basic_string<_Elem> _Str(_Pstr);
3188  const basic_string<_Elem> _Fmt(_Ptr);
3189  _STD regex_replace(_STD back_inserter(_Res), _Str.begin(), _Str.end(),
3190  _Re, _Fmt, _Flgs);
3191  return (_Res);
3192  }
back_inserter
back_insert_iterator< _Container > back_inserter(_Container &_Cont)
Definition: xutility:3750
regex_replace
_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)
Definition: regex:3052
basic_string
Definition: xstring:1866
_STD
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
2907  { // search for regular expression match in target text
2908  _DEBUG_RANGE(_First, _Last);
2909  return (_Regex_search1(_First, _Last, &_Matches, _Re, _Flgs, _First));
2910  }
_DEBUG_RANGE
#define _DEBUG_RANGE(first, last)
Definition: xutility:902
_Regex_search1
bool _Regex_search1(_It _First, _It _Last, match_results< _BidIt, _Alloc > *_Matches, const basic_regex< _Elem, _RxTraits > &_Re, regex_constants::match_flag_type _Flgs, _It _Org)
Definition: regex:2855
cliext::_Last
_FwdIt _Last
Definition: algorithm:1936
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
2919  { // search for regular expression match in target text
2920  _DEBUG_RANGE(_First, _Last);
2921  return (_Regex_search1(_Unchecked(_First), _Unchecked(_Last),
2922  static_cast<match_results<decltype(_Unchecked(_First))> *>(0), _Re,
2923  _Flgs | regex_constants::match_any, _Unchecked(_First)));
2924  }
_DEBUG_RANGE
#define _DEBUG_RANGE(first, last)
Definition: xutility:902
_Regex_search1
bool _Regex_search1(_It _First, _It _Last, match_results< _BidIt, _Alloc > *_Matches, const basic_regex< _Elem, _RxTraits > &_Re, regex_constants::match_flag_type _Flgs, _It _Org)
Definition: regex:2855
regex_constants::match_any
Definition: regex:122
match_results
Definition: regex:1153
cliext::_Unchecked
_Iter_t _Unchecked(_Iter_t _Iter)
Definition: iterator:11
cliext::_Last
_FwdIt _Last
Definition: algorithm:1936
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
2932  { // search for regular expression match in target text
2933  const _Elem *_Last = _Str + char_traits<_Elem>::length(_Str);
2934  return (_Regex_search1(_Str, _Last,
2935  static_cast<match_results<const _Elem *> *>(0), _Re,
2936  _Flgs | regex_constants::match_any, _Str));
2937  }
_Regex_search1
bool _Regex_search1(_It _First, _It _Last, match_results< _BidIt, _Alloc > *_Matches, const basic_regex< _Elem, _RxTraits > &_Re, regex_constants::match_flag_type _Flgs, _It _Org)
Definition: regex:2855
regex_constants::match_any
Definition: regex:122
match_results
Definition: regex:1153
_Char_traits< _Elem, long >::length
static size_t __CLRCALL_OR_CDECL length(_In_z_ const _Elem *_First) _NOEXCEPT
Definition: iosfwd:148
cliext::_Last
_FwdIt _Last
Definition: algorithm:1936
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
2947  { // search for regular expression match in target text
2948  const _Elem *_Last = _Str + char_traits<_Elem>::length(_Str);
2949  return (_Regex_search1(_Str, _Last, &_Matches, _Re, _Flgs, _Str));
2950  }
_Regex_search1
bool _Regex_search1(_It _First, _It _Last, match_results< _BidIt, _Alloc > *_Matches, const basic_regex< _Elem, _RxTraits > &_Re, regex_constants::match_flag_type _Flgs, _It _Org)
Definition: regex:2855
_Char_traits< _Elem, long >::length
static size_t __CLRCALL_OR_CDECL length(_In_z_ const _Elem *_First) _NOEXCEPT
Definition: iosfwd:148
cliext::_Last
_FwdIt _Last
Definition: algorithm:1936
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
2964  { // search for regular expression match in target text
2965  return (_Regex_search1(_Str.begin(), _Str.end(),
2966  &_Matches, _Re, _Flgs, _Str.begin()));
2967  }
_Regex_search1
bool _Regex_search1(_It _First, _It _Last, match_results< _BidIt, _Alloc > *_Matches, const basic_regex< _Elem, _RxTraits > &_Re, regex_constants::match_flag_type _Flgs, _It _Org)
Definition: regex:2855
basic_string::end
iterator end() _NOEXCEPT
Definition: xstring:2869
basic_string::begin
iterator begin() _NOEXCEPT
Definition: xstring:2857
template<class _StTraits , class _StAlloc , class _Alloc , class _Elem , class _RxTraits >
bool regex_search ( const basic_string< _Elem, _StTraits, _StAlloc > &&  ,
match_results< typename basic_string< _Elem, _StTraits, _StAlloc >::const_iterator, _Alloc > &  ,
const basic_regex< _Elem, _RxTraits > &  ,
regex_constants::match_flag_type  = regex_constants::match_default 
)
delete
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
2991  { // search for regular expression match in target text
2992  typedef typename basic_string<_Elem, _StTraits, _StAlloc>
2993  ::const_pointer _Iter;
2994 
2995  _Iter _First = _Str.c_str();
2996  _Iter _Last = _First + _Str.size();
2997  return (_Regex_search1(_First, _Last,
2998  static_cast<match_results<_Iter> *>(0), _Re,
2999  _Flgs | regex_constants::match_any, _First));
3000  }
basic_string::c_str
_Ret_z_ const _Elem * c_str() const _NOEXCEPT
Definition: xstring:3001
_Regex_search1
bool _Regex_search1(_It _First, _It _Last, match_results< _BidIt, _Alloc > *_Matches, const basic_regex< _Elem, _RxTraits > &_Re, regex_constants::match_flag_type _Flgs, _It _Org)
Definition: regex:2855
regex_constants::match_any
Definition: regex:122
match_results
Definition: regex:1153
basic_string::size
size_type size() const _NOEXCEPT
Definition: xstring:3023
basic_string
Definition: xstring:1866
cliext::_Last
_FwdIt _Last
Definition: algorithm:1936
template<class _Elem , class _RxTraits >
void swap ( basic_regex< _Elem, _RxTraits > &  _Left,
basic_regex< _Elem, _RxTraits > &  _Right 
)
2598  { // exchange contents of _Left with _Right
2599  _Left.swap(_Right);
2600  }
basic_regex::swap
void swap(_Myt &_Right) _THROW0()
Definition: regex:2521
template<class _BidIt , class _Alloc >
void swap ( match_results< _BidIt, _Alloc > &  _Left,
match_results< _BidIt, _Alloc > &  _Right 
)
2606  { // exchange contents of _Left with _Right
2607  _Left.swap(_Right);
2608  }
match_results::swap
void swap(match_results &_Right)
Definition: regex:1417

Variable Documentation

const unsigned int _ARRAY_THRESHOLD = 4U
const unsigned int _Bmp_chrs = 1U << _Bmp_shift
const unsigned int _Bmp_mask = _Bmp_chrs - 1U
const unsigned int _Bmp_max = 256U
const unsigned int _Bmp_shift = 3U
const unsigned int _Bmp_size = (_Bmp_max + _Bmp_chrs - 1U) / _Bmp_chrs
const unsigned int _BRE_MAX_GRP = 9U
const unsigned int _Buf_incr = 16U
Generated on Sat Jul 22 2017 14:35:52 for STLdoc by   doxygen 1.8.8