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)
 
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 
2206  { // describe language properties
2207  _L_ext_rep = 0x00000001, // + and ? repetitions
2208  _L_alt_pipe = 0x00000002, // uses '|' for alternation
2209  _L_alt_nl = 0x00000004, // uses '\n' for alternation (grep, egrep)
2210  _L_nex_grp = 0x00000008, // has non-escaped capture groups
2211  _L_nex_rep = 0x00000010, // has non-escaped repeats
2212  _L_nc_grp = 0x00000020, // has non-capture groups (?:xxx)
2213  _L_asrt_gen = 0x00000040, // has generalized assertions (?=xxx), (?!xxx)
2214  _L_asrt_wrd = 0x00000080, // has word boundary assertions (\b, \B)
2215  _L_bckr = 0x00000100, // has backreferences (ERE doesn't)
2216  _L_lim_bckr = 0x00000200, // has limited backreferences (BRE \1-\9)
2217  _L_ngr_rep = 0x00000400, // has non-greedy repeats
2218  _L_esc_uni = 0x00000800, // has Unicode escape sequences
2219  _L_esc_hex = 0x00001000, // has hexadecimal escape sequences
2220  _L_esc_oct = 0x00002000, // has octal escape sequences
2221  _L_esc_bsl = 0x00004000, // has escape backslash in character classes
2222  _L_esc_ffnx = 0x00008000, // has extra file escapes (\a and \b)
2223  _L_esc_ffn = 0x00010000, // has limited file escapes (\[fnrtv])
2224  _L_esc_wsd = 0x00020000, // has w, s, and d character set escapes
2225  _L_esc_ctrl = 0x00040000, // has control escape
2226  _L_no_nl = 0x00080000, // no newline in pattern or matching text
2227  _L_bzr_chr = 0x00100000, // \0 is a valid character constant
2228  _L_grp_esc = 0x00200000, // \ is special character in group
2229  _L_ident_ECMA = 0x00400000, // ECMA identity escape (not identifierpart)
2230  _L_ident_ERE = 0x00800000, // ERE identity escape (.[\*^$, plus {+?}()
2231  _L_ident_awk = 0x01000000, // awk identity escape ( ERE plus "/)
2232  _L_anch_rstr = 0x02000000, // anchor restricted to beginning/end
2233  _L_star_beg = 0x04000000, // star okay at beginning of RE/expr (BRE)
2234  _L_empty_grp = 0x08000000, // empty group allowed (ERE prohibits "()")
2235  _L_paren_bal = 0x10000000, // ')'/'}'/']' special only after '('/'{'/']'
2236  _L_brk_rstr = 0x20000000, // ']' not special when first character in set
2237  _L_mtch_long = 0x40000000, // find longest match (ERE, BRE)
2238  };
_L_nex_rep
Definition: regex:2211
_L_brk_rstr
Definition: regex:2236
_L_anch_rstr
Definition: regex:2232
_L_bzr_chr
Definition: regex:2227
_L_esc_bsl
Definition: regex:2221
_L_star_beg
Definition: regex:2233
_L_esc_uni
Definition: regex:2218
_L_esc_oct
Definition: regex:2220
_L_esc_ctrl
Definition: regex:2225
_L_asrt_wrd
Definition: regex:2214
_L_esc_ffn
Definition: regex:2223
_L_ident_ECMA
Definition: regex:2229
_L_grp_esc
Definition: regex:2228
_L_bckr
Definition: regex:2215
_L_ident_ERE
Definition: regex:2230
_L_empty_grp
Definition: regex:2234
_L_mtch_long
Definition: regex:2237
_L_esc_ffnx
Definition: regex:2222
_L_lim_bckr
Definition: regex:2216
_L_esc_hex
Definition: regex:2219
_L_ext_rep
Definition: regex:2207
_L_asrt_gen
Definition: regex:2213
_L_ident_awk
Definition: regex:2231
_L_nc_grp
Definition: regex:2212
_L_no_nl
Definition: regex:2226
_L_nex_grp
Definition: regex:2210
_L_esc_wsd
Definition: regex:2224
_L_ngr_rep
Definition: regex:2217
_L_paren_bal
Definition: regex:2235
_L_alt_nl
Definition: regex:2209
_L_alt_pipe
Definition: regex:2208
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 
54  { // meta character representations for parser
55  _Meta_lpar = '(',
56  _Meta_rpar = ')',
57  _Meta_dlr = '$',
58  _Meta_caret = '^',
59  _Meta_dot = '.',
60  _Meta_star = '*',
61  _Meta_plus = '+',
62  _Meta_query = '?',
63  _Meta_lsq = '[',
64  _Meta_rsq = ']',
65  _Meta_bar = '|',
66  _Meta_esc = '\\',
67  _Meta_dash = '-',
68  _Meta_lbr = '{',
69  _Meta_rbr = '}',
70  _Meta_comma = ',',
71  _Meta_colon = ':',
72  _Meta_equal = '=',
73  _Meta_exc = '!',
74  _Meta_eos = -1,
75  _Meta_nl = '\n',
76  _Meta_cr = '\r',
77  _Meta_bsp = '\b',
78  _Meta_chr = 0,
79 
80  _Esc_bsl = '\\',
81  _Esc_word = 'b',
82  _Esc_not_word = 'B',
83  _Esc_ctrl_a = 'a',
84  _Esc_ctrl_b = 'b',
85  _Esc_ctrl_f = 'f',
86  _Esc_ctrl_n = 'n',
87  _Esc_ctrl_r = 'r',
88  _Esc_ctrl_t = 't',
89  _Esc_ctrl_v = 'v',
90  _Esc_ctrl = 'c',
91  _Esc_hex = 'x',
92  _Esc_uni = 'u'
93  };
_Meta_eos
Definition: regex:74
_Meta_star
Definition: regex:60
_Meta_comma
Definition: regex:70
_Meta_rsq
Definition: regex:64
_Meta_exc
Definition: regex:73
_Meta_equal
Definition: regex:72
_Esc_ctrl_r
Definition: regex:87
_Esc_not_word
Definition: regex:82
_Esc_ctrl
Definition: regex:90
_Meta_bsp
Definition: regex:77
_Esc_ctrl_n
Definition: regex:86
_Meta_bar
Definition: regex:65
_Meta_caret
Definition: regex:58
_Meta_lpar
Definition: regex:55
_Meta_rbr
Definition: regex:69
_Esc_ctrl_b
Definition: regex:84
_Esc_hex
Definition: regex:91
_Meta_dash
Definition: regex:67
_Meta_chr
Definition: regex:78
_Esc_word
Definition: regex:81
_Meta_colon
Definition: regex:71
_Meta_lbr
Definition: regex:68
_Esc_ctrl_a
Definition: regex:83
_Meta_nl
Definition: regex:75
_Esc_ctrl_t
Definition: regex:88
_Meta_rpar
Definition: regex:56
_Meta_plus
Definition: regex:61
_Meta_query
Definition: regex:62
_Esc_uni
Definition: regex:92
_Esc_ctrl_v
Definition: regex:89
_Meta_cr
Definition: regex:76
_Meta_dlr
Definition: regex:57
_Esc_bsl
Definition: regex:80
_Esc_ctrl_f
Definition: regex:85
_Meta_esc
Definition: regex:66
_Meta_lsq
Definition: regex:63
_Meta_dot
Definition: regex:59
enum _Node_flags
Enumerator
_Fl_none 
_Fl_negate 
_Fl_greedy 
_Fl_final 
_Fl_longest 
1488  { // flags for nfa nodes with special properties
1489  _Fl_none = 0x00,
1490  _Fl_negate = 0x01,
1491  _Fl_greedy = 0x02,
1492  _Fl_final = 0x04,
1493  _Fl_longest = 0x08
1494  };
_Fl_none
Definition: regex:1489
_Fl_greedy
Definition: regex:1491
_Fl_longest
Definition: regex:1493
_Fl_negate
Definition: regex:1490
_Fl_final
Definition: regex:1492
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 
1512  { // type flag for nfa nodes
1513  _N_none,
1514  _N_nop,
1515  _N_bol,
1516  _N_eol,
1517  _N_wbound,
1518  _N_dot,
1519  _N_str,
1520  _N_class,
1521  _N_group,
1522  _N_end_group,
1523  _N_assert,
1524  _N_neg_assert,
1525  _N_end_assert,
1526  _N_capture,
1527  _N_end_capture,
1528  _N_back,
1529  _N_if,
1530  _N_endif,
1531  _N_rep,
1532  _N_end_rep,
1533  _N_begin,
1534  _N_end
1535  };
_N_str
Definition: regex:1519
_N_wbound
Definition: regex:1517
_N_dot
Definition: regex:1518
_N_end_assert
Definition: regex:1525
_N_end_rep
Definition: regex:1532
_N_group
Definition: regex:1521
_N_if
Definition: regex:1529
_N_neg_assert
Definition: regex:1524
_N_none
Definition: regex:1513
_N_end
Definition: regex:1534
_N_assert
Definition: regex:1523
_N_end_group
Definition: regex:1522
_N_eol
Definition: regex:1516
_N_rep
Definition: regex:1531
_N_begin
Definition: regex:1533
_N_end_capture
Definition: regex:1527
_N_back
Definition: regex:1528
_N_class
Definition: regex:1520
_N_endif
Definition: regex:1530
_N_nop
Definition: regex:1514
_N_bol
Definition: regex:1515
_N_capture
Definition: regex:1526
enum _Prs_ret
Enumerator
_Prs_none 
_Prs_chr 
_Prs_set 
2132  { // indicate class element type
2133  _Prs_none,
2134  _Prs_chr,
2135  _Prs_set
2136  };
_Prs_chr
Definition: regex:2134
_Prs_none
Definition: regex:2133
_Prs_set
Definition: regex:2135

Function Documentation

void _Calculate_loop_simplicity ( _Node_base *  _Nx,
_Node_base *  _Ne,
_Node_rep *  _Outer_rep 
)
inline
5653  { // walks regex NFA, calculates values of _Node_rep::_Simple_loop
5654  for (; _Nx != _Ne && _Nx != 0; _Nx = _Nx->_Next)
5655  {
5656  switch (_Nx->_Kind)
5657  {
5658  case _N_if:
5659  // _Node_if inside a _Node_rep makes the rep not simple
5660  if (_Outer_rep != 0)
5661  _Outer_rep->_Simple_loop = 0;
5662  // visit each branch of the if
5663  for (_Node_if *_Branch = static_cast<_Node_if *>(_Nx)->_Child;
5664  _Branch != 0;
5665  _Branch = _Branch->_Child)
5666  _Calculate_loop_simplicity(_Branch->_Next, _Branch->_Endif, _Outer_rep);
5667  break;
5668  case _N_assert:
5669  case _N_neg_assert:
5670  // visit the assertion body
5671  // note _Outer_rep being reset: the assertion regex is completely independent
5672  _Calculate_loop_simplicity(static_cast<_Node_assert *>(_Nx)->_Child, 0, 0);
5673  break;
5674  case _N_rep:
5675  // _Node_rep inside another _Node_rep makes both not simple
5676  if (_Outer_rep == 0)
5677  _Outer_rep = static_cast<_Node_rep *>(_Nx);
5678  else
5679  {
5680  _Outer_rep->_Simple_loop = 0;
5681  static_cast<_Node_rep *>(_Nx)->_Simple_loop = 0;
5682  }
5683  break;
5684  case _N_end_rep:
5685  if (_Outer_rep == static_cast<_Node_end_rep *>(_Nx)->_Begin_rep)
5686  {
5687  // if the _Node_rep is still undetermined when we reach its end, it is simple
5688  if (_Outer_rep->_Simple_loop == -1)
5689  _Outer_rep->_Simple_loop = 1;
5690  _Outer_rep = 0;
5691  }
5692  break;
5693  default:
5694  break;
5695  }
5696  }
5697  }
_Node_base::_Next
_Node_base * _Next
Definition: regex:1661
_N_end_rep
Definition: regex:1532
_Node_if
Definition: regex:1823
_N_if
Definition: regex:1529
_N_neg_assert
Definition: regex:1524
_N_assert
Definition: regex:1523
_Node_rep::_Simple_loop
int _Simple_loop
Definition: regex:1894
_N_rep
Definition: regex:1531
_Node_base::_Kind
_Node_type _Kind
Definition: regex:1659
_Calculate_loop_simplicity
void _Calculate_loop_simplicity(_Node_base *_Nx, _Node_base *_Ne, _Node_rep *_Outer_rep)
Definition: regex:5652
_Node_if::_Child
_Node_if * _Child
Definition: regex:1845
_Node_rep
Definition: regex:1875
template<class _BidIt1 , class _BidIt2 , class _Pr >
_BidIt1 _Cmp_chrange ( _BidIt1  _Begin1,
_BidIt1  _End1,
_BidIt2  _Begin2,
_BidIt2  _End2,
_Pr  _Pred 
)
inline
4344  { // compare character ranges
4345  _BidIt1 _Res = _Begin1;
4346  while (_Begin1 != _End1 && _Begin2 != _End2)
4347  if (!_Pred(*_Begin1++, *_Begin2++))
4348  return (_Res);
4349  return (_Begin2 == _End2 ? _Begin1 : _Res);
4350  }
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
4358  { // compare character ranges
4359  _BidIt1 _Res = _End1;
4360  if (_Sflags & regex_constants::icase)
4361  _Res = _Cmp_chrange(_Begin1, _End1, _Begin2, _End2,
4362  _Cmp_icase<_RxTraits>(_Traits));
4363  else if (_Sflags & regex_constants::collate)
4364  _Res = _Cmp_chrange(_Begin1, _End1, _Begin2, _End2,
4365  _Cmp_collate<_RxTraits>(_Traits));
4366  else
4367  _Res = _Cmp_chrange(_Begin1, _End1, _Begin2, _End2,
4368  _Cmp_cs<_RxTraits>());
4369  return (_Res);
4370  }
_Cmp_icase
Definition: regex:197
_Cmp_collate
Definition: regex:219
_Cmp_chrange
_BidIt1 _Cmp_chrange(_BidIt1 _Begin1, _BidIt1 _End1, _BidIt2 _Begin2, _BidIt2 _End2, _Pr _Pred)
Definition: regex:4342
regex_constants::icase
Definition: regex:108
_Cmp_cs
Definition: regex:187
regex_constants::collate
Definition: regex:111
void _Destroy_node ( _Node_base *  _Nx,
_Node_base *  _Ne = 0 
)
inline
1672  { // destroy sublist of nodes
1673  while (_Nx != _Ne && _Nx != 0)
1674  { // destroy node
1675  _Node_base *_Tmp = _Nx;
1676  _Nx = _Nx->_Next;
1677  _Tmp->_Next = 0;
1678  delete _Tmp;
1679  }
1680  }
_Node_base::_Next
_Node_base * _Next
Definition: regex:1661
_Node_base
Definition: regex:1651
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
2607  { // format with ECMAScript rules
2608  while (_First != _Last)
2609  { // process one character or escape sequence
2610  if (*_First != '$')
2611  *_Out++ = *_First++;
2612  else if (++_First == _Last)
2613  *_Out++ = '$'; // preserve $ at end
2614  else if (*_First == '$')
2615  { // replace $$
2616  *_Out++ = '$';
2617  ++_First;
2618  }
2619  else if (*_First == '`')
2620  { // replace $`
2621  _Out = _Copy_no_deprecate(_Match.prefix().first,
2622  _Match.prefix().second, _Out);
2623  ++_First;
2624  }
2625  else if (*_First == '\'')
2626  { // replace $'
2627  _Out = _Copy_no_deprecate(_Match.suffix().first,
2628  _Match.suffix().second, _Out);
2629  ++_First;
2630  }
2631  else if (*_First == '&')
2632  { // replace $&
2633  ++_First;
2634  if (_Match.size() != 0)
2635  _Out = _Copy_no_deprecate(_Match._At(0).first,
2636  _Match._At(0).second, _Out);
2637  }
2638  else if (_Isdigit(*_First))
2639  { // replace capture group descriptors $n, $nn
2640  int n = *_First++ - '0';
2641  const bool _Two_digits = _First != _Last && _Isdigit(*_First);
2642  if (_Two_digits)
2643  { // process second digit
2644  n *= 10;
2645  n += *_First++ - '0';
2646  }
2647  if (n == 0)
2648  { // preserve $0, $00
2649  *_Out++ = '$';
2650  *_Out++ = '0';
2651  if (_Two_digits)
2652  *_Out++ = '0';
2653  }
2654  else if (n < (int)_Match.size())
2655  _Out = _Copy_no_deprecate(_Match._At(n).first,
2656  _Match._At(n).second, _Out);
2657  }
2658  else
2659  { // replace $x
2660  *_Out++ = '$';
2661  *_Out++ = *_First++;
2662  }
2663  }
2664  return (_Out);
2665  }
pair::second
_Ty2 second
Definition: utility:243
_Out
basic_ostream< _Elem, _Traits > & _Out(basic_ostream< _Elem, _Traits > &_Os, _Ty _Dx)
Definition: random:151
match_results::size
size_type size() const
Definition: regex:1233
match_results::suffix
const_reference suffix() const
Definition: regex:1273
_Copy_no_deprecate
_OutIt _Copy_no_deprecate(_InIt _First, _InIt _Last, _OutIt _Dest)
Definition: xutility:2359
_Isdigit
#define _Isdigit(x)
Definition: regex:2596
match_results::prefix
const_reference prefix() const
Definition: regex:1268
pair::first
_Ty1 first
Definition: utility:242
match_results::_At
_Elem & _At(unsigned int _Sub)
Definition: regex:1426
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
2675  { // format with sed rules
2676  while (_First != _Last)
2677  { // process one character or escape sequence
2678  if (*_First == '&')
2679  { // replace with full match
2680  ++_First;
2681  if (_Match.size() != 0)
2682  _Out = _Copy_no_deprecate(_Match._At(0).first,
2683  _Match._At(0).second, _Out);
2684  }
2685  else if (*_First != '\\')
2686  *_Out++ = *_First++;
2687  else if (++_First == _Last)
2688  ; // drop backslash at end
2689  else if (_Isdigit(*_First))
2690  { // replace \n, including \0
2691  int n = *_First++ - '0';
2692  if (n < (int)_Match.size())
2693  _Out = _Copy_no_deprecate(_Match._At(n).first,
2694  _Match._At(n).second, _Out);
2695  }
2696  else
2697  *_Out++ = *_First++; // replace \x, including \\, \&
2698  }
2699  return (_Out);
2700  }
pair::second
_Ty2 second
Definition: utility:243
_Out
basic_ostream< _Elem, _Traits > & _Out(basic_ostream< _Elem, _Traits > &_Os, _Ty _Dx)
Definition: random:151
match_results::size
size_type size() const
Definition: regex:1233
_Copy_no_deprecate
_OutIt _Copy_no_deprecate(_InIt _First, _InIt _Last, _OutIt _Dest)
Definition: xutility:2359
_Isdigit
#define _Isdigit(x)
Definition: regex:2596
pair::first
_Ty1 first
Definition: utility:242
match_results::_At
_Elem & _At(unsigned int _Sub)
Definition: regex:1426
cliext::_Last
_FwdIt _Last
Definition: algorithm:1936
template<class _Traits , class _FwdIt1 , class _FwdIt2 >
int _Iter_compare ( _FwdIt1  _First1,
_FwdIt1  _Last1,
_FwdIt2  _First2,
_FwdIt2  _Last2 
)
inline
603  { // compare two iterator ranges:
604  // if [_First1, _Last1) is lexicographically less than [_First2, _Last2)
605  // a negative value
606  // if [_First2, _Last2) is lexicographically less than [_First1, _Last1)
607  // a positive value
608  // otherwise
609  // zero
610  typedef typename _Traits::char_type _Elem;
611  static_assert(conjunction<
612  is_same<_Iter_value_t<_FwdIt1>, _Elem>,
613  is_same<_Iter_value_t<_FwdIt2>, _Elem>>::value,
614  "bad iterators to _Iter_compare");
615 
616  _DEBUG_RANGE(_First1, _Last1);
617  _DEBUG_RANGE(_First2, _Last2);
618  return (_Iter_compare2<_Traits>(_Unchecked(_First1), _Unchecked(_Last1),
619  _Unchecked(_First2), _Unchecked(_Last2)));
620  }
_DEBUG_RANGE
#define _DEBUG_RANGE(first, last)
Definition: xutility:822
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:647
is_same
Definition: xtr1common:86
conjunction
Definition: type_traits:1039
template<class _Traits , class _FwdIt1 , class _FwdIt2 >
int _Iter_compare2 ( _FwdIt1  _First1,
_FwdIt1  _Last1,
_FwdIt2  _First2,
_FwdIt2  _Last2 
)
inline
593  { // decide which _Iter_compare implementation to use
594  return (_Iter_compare3<_Traits>(_First1, _Last1, _First2, _Last2,
595  typename conjunction<is_pointer<_FwdIt1>, is_pointer<_FwdIt2>>::type{}));
596  }
is_pointer
Definition: type_traits:298
conjunction
Definition: type_traits:1039
template<class _Traits , class _FwdIt1 , class _FwdIt2 >
int _Iter_compare3 ( _FwdIt1  _First1,
_FwdIt1  _Last1,
_FwdIt2  _First2,
_FwdIt2  _Last2,
true_type   
)
inline
546  { // _Iter_compare for memory buffer ranges
547  const size_t _Len1 = _Last1 - _First1;
548  const size_t _Len2 = _Last2 - _First2;
549  const int _Ans = _Traits::compare(_First1, _First2, (_STD min)(_Len1, _Len2));
550  if (_Ans != 0)
551  return (_Ans);
552 
553  if (_Len1 < _Len2)
554  return (-1);
555 
556  if (_Len2 < _Len1)
557  return (1);
558 
559  return (0);
560  }
_STD
min
constexpr const _Ty &() min(const _Ty &_Left, const _Ty &_Right, _Pr _Pred) _NOEXCEPT_OP(_NOEXCEPT_OP(_DEBUG_LT_PRED(_Pred
template<class _Traits , class _FwdIt1 , class _FwdIt2 >
int _Iter_compare3 ( _FwdIt1  _First1,
_FwdIt1  _Last1,
_FwdIt2  _First2,
_FwdIt2  _Last2,
false_type   
)
inline
567  { // _Iter_compare for general ranges
568  const pair<_FwdIt1, _FwdIt2> _Cmp = _STD mismatch(_First1, _Last1,
569  _First2, _Last2, _Char_traits_eq<_Traits>{});
570 
571  if (_Cmp.first == _Last1)
572  {
573  if (_Cmp.second == _Last2)
574  return (0);
575  else
576  return (-1);
577  }
578 
579  if (_Cmp.second == _Last2)
580  return (1);
581 
582  if (_Traits::lt(*_Cmp.first, *_Cmp.second))
583  return (-1);
584  else
585  return (1);
586  }
pair::second
_Ty2 second
Definition: utility:243
_Char_traits_eq
Definition: xutility:2274
pair::first
_Ty1 first
Definition: utility:242
mismatch
pair< _InIt1, _InIt2 > mismatch(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _Pr _Pred)
Definition: algorithm:210
pair
Definition: utility:75
_STD
template<class _BidIt , class _Elem >
_BidIt _Lookup_coll ( _BidIt  _First,
_BidIt  _Last,
const _Sequence< _Elem > *  _Eq 
)
inline
4412  { // look for collation element [_First, _Last) in _Eq
4413  while (_Eq)
4414  { // look for sequence of elements that are the right size
4415  for (unsigned int _Ix = 0; _Ix < _Eq->_Data._Size(); _Ix += _Eq->_Sz)
4416  { // look for character range
4417  _BidIt _Res = _First;
4418  for (size_t _Jx = 0; _Jx < _Eq->_Sz; ++_Jx)
4419  { // check current character
4420  if (*_Res++ != *(_Eq->_Data._Str() + _Ix + _Jx))
4421  break;
4422  }
4423  if (_Res == _Last)
4424  return (_Last);
4425  }
4426  _Eq = _Eq->_Next;
4427  }
4428  return (_First);
4429  }
_Sequence::_Data
_Buf< _Elem > _Data
Definition: regex:1646
_Sequence::_Next
_Sequence * _Next
Definition: regex:1647
_Sequence::_Sz
unsigned int _Sz
Definition: regex:1645
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
4390  { // check whether _Ch is in _Eq
4391  typename _RxTraits::string_type _Str0;
4392  typename _RxTraits::string_type _Str1(1, _Ch);
4393  _Str1 = _Traits.transform_primary(_Str1.begin(), _Str1.end());
4394  while (_Eq)
4395  { // look for sequence of elements that are the right size
4396  for (unsigned int _Ix = 0; _Ix < _Eq->_Data._Size(); _Ix += _Eq->_Sz)
4397  { // look for _Ch
4398  _Str0.assign(_Eq->_Data._Str() + _Ix, _Eq->_Sz);
4399  _Str0 = _Traits.transform_primary(_Str0.begin(), _Str0.end());
4400  if (_Str0 == _Str1)
4401  return (true);
4402  }
4403  _Eq = _Eq->_Next;
4404  }
4405  return (false);
4406  }
_Sequence::_Data
_Buf< _Elem > _Data
Definition: regex:1646
_Sequence::_Next
_Sequence * _Next
Definition: regex:1647
_Ch
_Check_return_ _In_ wchar_t _Ch
Definition: vcruntime_string.h:89
_Sequence::_Sz
unsigned int _Sz
Definition: regex:1645
template<class _Elem >
bool _Lookup_range ( unsigned int  _Ch,
const _Buf< _Elem > *  _Bufptr 
)
inline
4374  { // check whether _Ch is in _Buf
4375  typedef typename make_unsigned<_Elem>::type _Uelem;
4376  for (unsigned int _Ix = 0; _Ix < _Bufptr->_Size(); _Ix += 2)
4377  { // check current position
4378  if ((_Uelem)_Bufptr->_At(_Ix) <= _Ch
4379  && _Ch <= (_Uelem)_Bufptr->_At(_Ix + 1))
4380  return (true);
4381  }
4382  return (false);
4383  }
_Buf::_Size
unsigned int _Size() const
Definition: regex:1551
_Ch
_Check_return_ _In_ wchar_t _Ch
Definition: vcruntime_string.h:89
_Buf::_At
_Elem _At(unsigned int _Idx) const
Definition: regex:1556
_Invoker_pmd_pointer
Definition: type_traits:1356
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
2715  { // try to match regular expression to target text
2716  if (_Re._Empty())
2717  return (false);
2718  _Matcher<_BidIt, _Elem, _RxTraits, _It> _Mx(_First, _Last,
2719  _Re._Get_traits(), _Re._Get(), _Re.mark_count() + 1, _Re.flags(),
2720  _Flgs);
2721  return (_Mx._Match(_Matches, _Full));
2722  }
basic_regex::mark_count
unsigned int mark_count() const
Definition: regex:2435
basic_regex::flags
flag_type flags() const
Definition: regex:2484
basic_regex::_Empty
bool _Empty() const
Definition: regex:2514
basic_regex::_Get
_Root_node * _Get() const
Definition: regex:2509
basic_regex::_Get_traits
const _RxTraits & _Get_traits() const
Definition: regex:2519
cliext::_Last
_FwdIt _Last
Definition: algorithm:1936
_Matcher
Definition: regex:2000
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
2993  { // search and replace
2994  match_results<_BidIt> _Matches;
2995  _BidIt _Pos = _First;
2996  regex_constants::match_flag_type _Flags = _Flgs;
2997  regex_constants::match_flag_type _Not_null =
2998  (regex_constants::match_flag_type)0;
2999 
3000  while (_Regex_search1(_Pos, _Last, &_Matches, _Re, _Flags | _Not_null, _Pos))
3001  { // replace at each match
3002  if (!(_Flgs & regex_constants::format_no_copy))
3003  _Result = _Copy_no_deprecate(_Matches.prefix().first,
3004  _Matches.prefix().second, _Result);
3005  _Result = _Matches._Format1(_Result,
3006  _Unchecked(_Fmt.begin()), _Unchecked(_Fmt.end()), _Flags);
3007 
3008  _Pos = _Matches[0].second;
3009  if (_Pos == _Last
3010  || _Flgs & regex_constants::format_first_only)
3011  break;
3012 
3013  if (_Matches[0].first == _Matches[0].second)
3014  _Not_null = regex_constants::_Match_not_null;
3015  else
3016  { // non-null match, recognize earlier text
3017  _Not_null = (regex_constants::match_flag_type)0;
3018  _Flags |= regex_constants::match_prev_avail;
3019  }
3020  }
3021  return (_Flgs & regex_constants::format_no_copy
3022  ? _Result : _Copy_no_deprecate(_Pos, _Last, _Result));
3023  }
pair::second
_Ty2 second
Definition: utility:243
_Copy_no_deprecate
_OutIt _Copy_no_deprecate(_InIt _First, _InIt _Last, _OutIt _Dest)
Definition: xutility:2359
_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:2834
regex_constants::_Match_not_null
Definition: regex:131
regex_constants::match_flag_type
match_flag_type
Definition: regex:116
match_results::prefix
const_reference prefix() const
Definition: regex:1268
match_results< _BidIt >
pair::first
_Ty1 first
Definition: utility:242
regex_constants::format_no_copy
Definition: regex:129
basic_string::end
iterator end() _NOEXCEPT
Definition: xstring:1605
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:1299
basic_string::begin
iterator begin() _NOEXCEPT
Definition: xstring:1593
regex_constants::match_prev_avail
Definition: regex:126
cliext::_Last
_FwdIt _Last
Definition: algorithm:1936
regex_constants::format_first_only
Definition: regex:130
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
2839  { // search for regular expression match in target text
2840  if (_Re._Empty())
2841  return (false);
2842  bool _Found = false;
2843  _It _Begin = _First;
2844  _Matcher<_BidIt, _Elem, _RxTraits, _It> _Mx(_First, _Last,
2845  _Re._Get_traits(), _Re._Get(), _Re.mark_count() + 1, _Re.flags(),
2846  _Flgs);
2847 
2848  if (_Mx._Match(_Matches, false))
2849  _Found = true;
2850  else if (_First == _Last
2851  || _Flgs & regex_constants::match_continuous)
2852  ;
2853  else
2854  { // try more on suffixes
2855  _Mx._Setf(regex_constants::match_prev_avail);
2856  _Mx._Clearf(regex_constants::_Match_not_null);
2857  while ((_First = _Mx._Skip(++_First, _Last)) != _Last)
2858  if (_Mx._Match(_First, _Matches, false))
2859  { // found match starting at _First
2860  _Found = true;
2861  break;
2862  }
2863  if (!_Found && _Mx._Match(_Last, _Matches, false))
2864  _Found = true;
2865  }
2866  if (_Found && _Matches)
2867  { // update _Matches
2868  _Matches->_Org = _Org;
2869  _Matches->_Pfx().first = _Begin;
2870  _Matches->_Pfx().matched =
2871  _Matches->_Pfx().first != _Matches->_Pfx().second;
2872  }
2873  return (_Found);
2874  }
pair::second
_Ty2 second
Definition: utility:243
regex_constants::match_continuous
Definition: regex:125
match_results::_Org
_BidIt _Org
Definition: regex:1436
basic_regex::mark_count
unsigned int mark_count() const
Definition: regex:2435
sub_match::matched
bool matched
Definition: regex:643
basic_regex::flags
flag_type flags() const
Definition: regex:2484
regex_constants::_Match_not_null
Definition: regex:131
pair::first
_Ty1 first
Definition: utility:242
_Matcher::_Setf
void _Setf(regex_constants::match_flag_type _Mf)
Definition: regex:2017
match_results::_Pfx
_Elem & _Pfx()
Definition: regex:1411
basic_regex::_Empty
bool _Empty() const
Definition: regex:2514
basic_regex::_Get
_Root_node * _Get() const
Definition: regex:2509
regex_constants::match_prev_avail
Definition: regex:126
basic_regex::_Get_traits
const _RxTraits & _Get_traits() const
Definition: regex:2519
cliext::_Last
_FwdIt _Last
Definition: algorithm:1936
_Matcher
Definition: regex:2000
_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
767  { // test for inequality
768  return (!(_Left == _Right));
769  }
template<class _BidIt >
bool operator!= ( const _Iter_value_t< _BidIt > *  _Left,
const sub_match< _BidIt > &  _Right 
)
inline
816  { // test for inequality
817  return (!(_Left == _Right));
818  }
_Left
constexpr const _Ty &() _Left
Definition: algorithm:3590
template<class _BidIt >
bool operator!= ( const sub_match< _BidIt > &  _Left,
const _Iter_value_t< _BidIt > *  _Right 
)
inline
864  { // test for inequality
865  return (!(_Left == _Right));
866  }
_Right
constexpr const _Ty &() _Right
Definition: algorithm:3591
template<class _BidIt >
bool operator!= ( const _Iter_value_t< _BidIt > &  _Left,
const sub_match< _BidIt > &  _Right 
)
inline
913  { // test for inequality
914  return (!(_Left == _Right));
915  }
_Left
constexpr const _Ty &() _Left
Definition: algorithm:3590
template<class _BidIt >
bool operator!= ( const sub_match< _BidIt > &  _Left,
const _Iter_value_t< _BidIt > &  _Right 
)
inline
961  { // test for inequality
962  return (!(_Left == _Right));
963  }
_Right
constexpr const _Ty &() _Right
Definition: algorithm:3591
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
1014  { // test for inequality
1015  return (!(_Left == _Right));
1016  }
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
1074  { // test for inequality
1075  return (!(_Left == _Right));
1076  }
template<class _BidIt , class _Alloc >
bool operator!= ( const match_results< _BidIt, _Alloc > &  _Left,
const match_results< _BidIt, _Alloc > &  _Right 
)
1471  { // compare results for inequality
1472  return (!(_Left == _Right));
1473  }
template<class _BidIt >
bool operator< ( const sub_match< _BidIt > &  _Left,
const sub_match< _BidIt > &  _Right 
)
inline
775  { // test if _Left < _Right
776  return (_Left._Less(_Right));
777  }
sub_match::_Less
bool _Less(const sub_match &_Right) const
Definition: regex:707
template<class _BidIt >
bool operator< ( const _Iter_value_t< _BidIt > *  _Left,
const sub_match< _BidIt > &  _Right 
)
inline
824  { // test if _Left < _Right
825  return (_Right._Greater(_Left));
826  }
_Left
constexpr const _Ty &() _Left
Definition: algorithm:3590
sub_match::_Greater
bool _Greater(const value_type *const _Ptr, const _Size_type _Count) const
Definition: regex:727
template<class _BidIt >
bool operator< ( const sub_match< _BidIt > &  _Left,
const _Iter_value_t< _BidIt > *  _Right 
)
inline
872  { // test if _Left < _Right
873  return (_Left._Less(_Right));
874  }
sub_match::_Less
bool _Less(const sub_match &_Right) const
Definition: regex:707
_Right
constexpr const _Ty &() _Right
Definition: algorithm:3591
template<class _BidIt >
bool operator< ( const _Iter_value_t< _BidIt > &  _Left,
const sub_match< _BidIt > &  _Right 
)
inline
921  { // test if _Left < _Right
922  return (_Right._Greater(&_Left, 1));
923  }
_Left
constexpr const _Ty &() _Left
Definition: algorithm:3590
sub_match::_Greater
bool _Greater(const value_type *const _Ptr, const _Size_type _Count) const
Definition: regex:727
template<class _BidIt >
bool operator< ( const sub_match< _BidIt > &  _Left,
const _Iter_value_t< _BidIt > &  _Right 
)
inline
969  { // test if _Left < _Right
970  return (_Left._Less(&_Right, 1));
971  }
sub_match::_Less
bool _Less(const sub_match &_Right) const
Definition: regex:707
_Right
constexpr const _Ty &() _Right
Definition: algorithm:3591
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
1024  { // test if _Left < _Right
1025  return (_Left._Less(_Right.data(), _Right.size()));
1026  }
basic_string::data
const _Elem * data() const _NOEXCEPT
Definition: xstring:1746
sub_match::_Less
bool _Less(const sub_match &_Right) const
Definition: regex:707
basic_string::size
size_type size() const _NOEXCEPT
Definition: xstring:1763
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
1084  { // test if _Left < _Right
1085  return (_Right._Greater(_Left.data(), _Left.size()));
1086  }
basic_string::data
const _Elem * data() const _NOEXCEPT
Definition: xstring:1746
basic_string::size
size_type size() const _NOEXCEPT
Definition: xstring:1763
sub_match::_Greater
bool _Greater(const value_type *const _Ptr, const _Size_type _Count) const
Definition: regex:727
template<class _Elem , class _Traits , class _BidIt >
basic_ostream<_Elem, _Traits>& operator<< ( basic_ostream< _Elem, _Traits > &  _Ostr,
const sub_match< _BidIt > &  _Match 
)
1125  { // insert into basic_ostream
1126  return (_Ostr << _Match.str());
1127  }
sub_match::str
string_type str() const
Definition: regex:656
template<class _BidIt >
bool operator<= ( const sub_match< _BidIt > &  _Left,
const sub_match< _BidIt > &  _Right 
)
inline
791  { // test if _Left <= _Right
792  return (!(_Right < _Left));
793  }
template<class _BidIt >
bool operator<= ( const _Iter_value_t< _BidIt > *  _Left,
const sub_match< _BidIt > &  _Right 
)
inline
840  { // test if _Left <= _Right
841  return (!(_Right < _Left));
842  }
_Left
constexpr const _Ty &() _Left
Definition: algorithm:3590
template<class _BidIt >
bool operator<= ( const sub_match< _BidIt > &  _Left,
const _Iter_value_t< _BidIt > *  _Right 
)
inline
888  { // test if _Left <= _Right
889  return (!(_Right < _Left));
890  }
_Right
constexpr const _Ty &() _Right
Definition: algorithm:3591
template<class _BidIt >
bool operator<= ( const _Iter_value_t< _BidIt > &  _Left,
const sub_match< _BidIt > &  _Right 
)
inline
937  { // test if _Left <= _Right
938  return (!(_Right < _Left));
939  }
_Left
constexpr const _Ty &() _Left
Definition: algorithm:3590
template<class _BidIt >
bool operator<= ( const sub_match< _BidIt > &  _Left,
const _Iter_value_t< _BidIt > &  _Right 
)
inline
985  { // test if _Left <= _Right
986  return (!(_Right < _Left));
987  }
_Right
constexpr const _Ty &() _Right
Definition: algorithm:3591
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
1044  { // test if _Left <= _Right
1045  return (!(_Right < _Left));
1046  }
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
1104  { // test if _Left <= _Right
1105  return (!(_Right < _Left));
1106  }
template<class _BidIt >
bool operator== ( const sub_match< _BidIt > &  _Left,
const sub_match< _BidIt > &  _Right 
)
inline
759  { // test for equality
760  return (_Left._Match_equal(_Right));
761  }
sub_match::_Match_equal
bool _Match_equal(const sub_match &_Right) const
Definition: regex:687
template<class _BidIt >
bool operator== ( const _Iter_value_t< _BidIt > *  _Left,
const sub_match< _BidIt > &  _Right 
)
inline
808  { // test for equality
809  return (_Right._Match_equal(_Left));
810  }
_Left
constexpr const _Ty &() _Left
Definition: algorithm:3590
sub_match::_Match_equal
bool _Match_equal(const sub_match &_Right) const
Definition: regex:687
template<class _BidIt >
bool operator== ( const sub_match< _BidIt > &  _Left,
const _Iter_value_t< _BidIt > *  _Right 
)
inline
856  { // test for equality
857  return (_Left._Match_equal(_Right));
858  }
sub_match::_Match_equal
bool _Match_equal(const sub_match &_Right) const
Definition: regex:687
_Right
constexpr const _Ty &() _Right
Definition: algorithm:3591
template<class _BidIt >
bool operator== ( const _Iter_value_t< _BidIt > &  _Left,
const sub_match< _BidIt > &  _Right 
)
inline
905  { // test for equality
906  return (_Right._Match_equal(&_Left, 1));
907  }
_Left
constexpr const _Ty &() _Left
Definition: algorithm:3590
sub_match::_Match_equal
bool _Match_equal(const sub_match &_Right) const
Definition: regex:687
template<class _BidIt >
bool operator== ( const sub_match< _BidIt > &  _Left,
const _Iter_value_t< _BidIt > &  _Right 
)
inline
953  { // test for equality
954  return (_Left._Match_equal(&_Right, 1));
955  }
sub_match::_Match_equal
bool _Match_equal(const sub_match &_Right) const
Definition: regex:687
_Right
constexpr const _Ty &() _Right
Definition: algorithm:3591
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
1004  { // test for equality
1005  return (_Left._Match_equal(_Right.data(), _Right.size()));
1006  }
basic_string::data
const _Elem * data() const _NOEXCEPT
Definition: xstring:1746
basic_string::size
size_type size() const _NOEXCEPT
Definition: xstring:1763
sub_match::_Match_equal
bool _Match_equal(const sub_match &_Right) const
Definition: regex:687
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
1064  { // test for equality
1065  return (_Right._Match_equal(_Left.data(), _Left.size()));
1066  }
basic_string::data
const _Elem * data() const _NOEXCEPT
Definition: xstring:1746
basic_string::size
size_type size() const _NOEXCEPT
Definition: xstring:1763
sub_match::_Match_equal
bool _Match_equal(const sub_match &_Right) const
Definition: regex:687
template<class _BidIt , class _Alloc >
bool operator== ( const match_results< _BidIt, _Alloc > &  _Left,
const match_results< _BidIt, _Alloc > &  _Right 
)
1451  { // compare results for equality
1452  if (!_Left.ready() && !_Right.ready())
1453  return (true);
1454  else if (!_Left.ready() || !_Right.ready())
1455  return (false);
1456  else if (_Left.empty() && _Right.empty())
1457  return (true);
1458  else if (_Left.empty() || _Right.empty())
1459  return (false);
1460  else
1461  return (_Left.size() == _Right.size()
1462  && _Left.prefix() == _Right.prefix()
1463  && _Left.suffix() == _Right.suffix()
1464  && _STD equal(_Left.begin(), _Left.end(), _Right.begin()));
1465  }
match_results::size
size_type size() const
Definition: regex:1233
match_results::empty
bool empty() const
Definition: regex:1243
match_results::suffix
const_reference suffix() const
Definition: regex:1273
match_results::end
const_iterator end() const
Definition: regex:1283
match_results::prefix
const_reference prefix() const
Definition: regex:1268
match_results::ready
bool ready() const
Definition: regex:1228
match_results::begin
const_iterator begin() const
Definition: regex:1278
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
783  { // test if _Left > _Right
784  return (_Right < _Left);
785  }
template<class _BidIt >
bool operator> ( const _Iter_value_t< _BidIt > *  _Left,
const sub_match< _BidIt > &  _Right 
)
inline
832  { // test if _Left > _Right
833  return (_Right < _Left);
834  }
_Left
constexpr const _Ty &() _Left
Definition: algorithm:3590
template<class _BidIt >
bool operator> ( const sub_match< _BidIt > &  _Left,
const _Iter_value_t< _BidIt > *  _Right 
)
inline
880  { // test if _Left > _Right
881  return (_Right < _Left);
882  }
_Right
constexpr const _Ty &() _Right
Definition: algorithm:3591
template<class _BidIt >
bool operator> ( const _Iter_value_t< _BidIt > &  _Left,
const sub_match< _BidIt > &  _Right 
)
inline
929  { // test if _Left > _Right
930  return (_Right < _Left);
931  }
_Left
constexpr const _Ty &() _Left
Definition: algorithm:3590
template<class _BidIt >
bool operator> ( const sub_match< _BidIt > &  _Left,
const _Iter_value_t< _BidIt > &  _Right 
)
inline
977  { // test if _Left > _Right
978  return (_Right < _Left);
979  }
_Right
constexpr const _Ty &() _Right
Definition: algorithm:3591
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
1034  { // test if _Left > _Right
1035  return (_Right < _Left);
1036  }
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
1094  { // test if _Left > _Right
1095  return (_Right < _Left);
1096  }
template<class _BidIt >
bool operator>= ( const sub_match< _BidIt > &  _Left,
const sub_match< _BidIt > &  _Right 
)
inline
799  { // test if _Left >= _Right
800  return (!(_Left < _Right));
801  }
template<class _BidIt >
bool operator>= ( const _Iter_value_t< _BidIt > *  _Left,
const sub_match< _BidIt > &  _Right 
)
inline
848  { // test if _Left >= _Right
849  return (!(_Left < _Right));
850  }
_Left
constexpr const _Ty &() _Left
Definition: algorithm:3590
template<class _BidIt >
bool operator>= ( const sub_match< _BidIt > &  _Left,
const _Iter_value_t< _BidIt > *  _Right 
)
inline
896  { // test if _Left >= _Right
897  return (!(_Left < _Right));
898  }
_Right
constexpr const _Ty &() _Right
Definition: algorithm:3591
template<class _BidIt >
bool operator>= ( const _Iter_value_t< _BidIt > &  _Left,
const sub_match< _BidIt > &  _Right 
)
inline
945  { // test if _Left >= _Right
946  return (!(_Left < _Right));
947  }
_Left
constexpr const _Ty &() _Left
Definition: algorithm:3590
template<class _BidIt >
bool operator>= ( const sub_match< _BidIt > &  _Left,
const _Iter_value_t< _BidIt > &  _Right 
)
inline
993  { // test if _Left >= _Right
994  return (!(_Left < _Right));
995  }
_Right
constexpr const _Ty &() _Right
Definition: algorithm:3591
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
1054  { // test if _Left >= _Right
1055  return (!(_Left < _Right));
1056  }
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
1114  { // test if _Left >= _Right
1115  return (!(_Left < _Right));
1116  }
_Node_flags operator^= ( _Node_flags &  _Left,
_Node_flags  _Right 
)
inline
1507  { // bitwise xor
1508  return (_Left = _Node_flags((int)_Left ^ _Right));
1509  }
_Left
constexpr const _Ty &() _Left
Definition: algorithm:3590
_Node_flags
_Node_flags
Definition: regex:1487
_Right
constexpr const _Ty &() _Right
Definition: algorithm:3591
_Node_flags operator| ( _Node_flags  _Left,
_Node_flags  _Right 
)
inline
1497  { // bitwise or
1498  return (_Node_flags((int)_Left | _Right));
1499  }
_Left
constexpr const _Ty &() _Left
Definition: algorithm:3590
_Node_flags
_Node_flags
Definition: regex:1487
_Right
constexpr const _Ty &() _Right
Definition: algorithm:3591
_Node_flags operator|= ( _Node_flags &  _Left,
_Node_flags  _Right 
)
inline
1502  { // bitwise or
1503  return (_Left = _Node_flags((int)_Left | _Right));
1504  }
_Left
constexpr const _Ty &() _Left
Definition: algorithm:3590
_Node_flags
_Node_flags
Definition: regex:1487
_Right
constexpr const _Ty &() _Right
Definition: algorithm:3591
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
2734  { // try to match regular expression to target text
2735  _DEBUG_RANGE(_First, _Last);
2736  return (_Regex_match1(_First, _Last,
2737  &_Matches, _Re, _Flgs, true));
2738  }
_DEBUG_RANGE
#define _DEBUG_RANGE(first, last)
Definition: xutility:822
_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:2710
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
2747  { // try to match regular expression to target text
2748  _DEBUG_RANGE(_First, _Last);
2749  return (_Regex_match1(_Unchecked(_First), _Unchecked(_Last),
2750  static_cast<match_results<decltype(_Unchecked(_First))> *>(0), _Re,
2751  _Flgs | regex_constants::match_any, true));
2752  }
_DEBUG_RANGE
#define _DEBUG_RANGE(first, last)
Definition: xutility:822
regex_constants::match_any
Definition: regex:123
match_results
Definition: regex:1132
_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:2710
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
2760  { // try to match regular expression to target text
2761  const _Elem *_Last = _Str + char_traits<_Elem>::length(_Str);
2762  return (_Regex_match1(_Str, _Last,
2763  static_cast<match_results<const _Elem *> *>(0), _Re,
2764  _Flgs | regex_constants::match_any, true));
2765  }
regex_constants::match_any
Definition: regex:123
match_results
Definition: regex:1132
_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:2710
cliext::_Last
_FwdIt _Last
Definition: algorithm:1936
_Char_traits< _Elem, long >::length
static size_t __CLRCALL_OR_CDECL length(_In_z_ const _Elem *_First)
Definition: iosfwd:151
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
2775  { // try to match regular expression to target text
2776  const _Elem *_Last = _Str + char_traits<_Elem>::length(_Str);
2777  return (_Regex_match1(_Str, _Last,
2778  &_Matches, _Re, _Flgs, true));
2779  }
_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:2710
cliext::_Last
_FwdIt _Last
Definition: algorithm:1936
_Char_traits< _Elem, long >::length
static size_t __CLRCALL_OR_CDECL length(_In_z_ const _Elem *_First)
Definition: iosfwd:151
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
2793  { // try to match regular expression to target text
2794  return (_Regex_match1(_Str.begin(), _Str.end(),
2795  &_Matches, _Re, _Flgs, true));
2796  }
_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:2710
basic_string::end
iterator end() _NOEXCEPT
Definition: xstring:1605
basic_string::begin
iterator begin() _NOEXCEPT
Definition: xstring:1593
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
2820  { // try to match regular expression to target text
2821  typedef typename basic_string<_Elem, _StTraits, _StAlloc>
2822  ::const_iterator _Iter;
2823  return (_Regex_match1(_Unchecked(_Str.begin()), _Unchecked(_Str.end()),
2824  static_cast<match_results<decltype(_Unchecked(_Str.begin()))> *>(0), _Re,
2825  _Flgs | regex_constants::match_any, true));
2826  }
regex_constants::match_any
Definition: regex:123
match_results
Definition: regex:1132
experimental::filesystem::v1::begin
const directory_iterator & begin(const directory_iterator &_Iter) _NOEXCEPT
Definition: filesystem:1968
_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:2710
basic_string::end
iterator end() _NOEXCEPT
Definition: xstring:1605
cliext::_Unchecked
_Iter_t _Unchecked(_Iter_t _Iter)
Definition: iterator:11
basic_string::begin
iterator begin() _NOEXCEPT
Definition: xstring:1593
basic_string
Definition: xstring:21
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
3037  { // search and replace, iterator result, string format
3038  _DEPRECATE_UNCHECKED(regex_replace, _Result);
3039  _DEBUG_RANGE(_First, _Last);
3040  return (_Rechecked(_Result,
3041  _Regex_replace1(_Unchecked_idl0(_Result), _Unchecked(_First), _Unchecked(_Last),
3042  _Re, _Fmt, _Flgs)));
3043  }
_DEPRECATE_UNCHECKED
#define _DEPRECATE_UNCHECKED(_Func, _Iter)
Definition: xutility:478
_DEBUG_RANGE
#define _DEBUG_RANGE(first, last)
Definition: xutility:822
_Rechecked
_Deque_const_iterator< _Mydeque > & _Rechecked(_Deque_const_iterator< _Mydeque > &_Iter, typename _Deque_const_iterator< _Mydeque >::_Unchecked_type _Right)
Definition: deque:534
_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:2988
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:3031
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
3076  { // search and replace, iterator result, NTBS format
3077  const basic_string<_Elem> _Fmt(_Ptr);
3078  return (_STD regex_replace(_Result,
3079  _First, _Last, _Re, _Fmt, _Flgs));
3080  }
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:3031
basic_string
Definition: xstring:21
_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 
)
3113  { // search and replace, string result, string target, string format
3114  basic_string<_Elem, _Traits1, _Alloc1> _Res;
3115  _STD regex_replace(_STD back_inserter(_Res), _Str.begin(), _Str.end(),
3116  _Re, _Fmt, _Flgs);
3117  return (_Res);
3118  }
back_inserter
back_insert_iterator< _Container > back_inserter(_Container &_Cont)
Definition: iterator:69
basic_string::end
iterator end() _NOEXCEPT
Definition: xstring:1605
basic_string::begin
iterator begin() _NOEXCEPT
Definition: xstring:1593
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:3031
basic_string
Definition: xstring:21
_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 
)
3130  { // search and replace, string result, string target, NTBS format
3131  basic_string<_Elem, _Traits1, _Alloc1> _Res;
3132  const basic_string<_Elem> _Fmt(_Ptr);
3133  _STD regex_replace(_STD back_inserter(_Res), _Str.begin(), _Str.end(),
3134  _Re, _Fmt, _Flgs);
3135  return (_Res);
3136  }
back_inserter
back_insert_iterator< _Container > back_inserter(_Container &_Cont)
Definition: iterator:69
basic_string::end
iterator end() _NOEXCEPT
Definition: xstring:1605
basic_string::begin
iterator begin() _NOEXCEPT
Definition: xstring:1593
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:3031
basic_string
Definition: xstring:21
_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 
)
3148  { // search and replace, string result, NTBS target, string format
3149  basic_string<_Elem> _Res;
3150  const basic_string<_Elem> _Str(_Pstr);
3151  _STD regex_replace(_STD back_inserter(_Res), _Str.begin(), _Str.end(),
3152  _Re, _Fmt, _Flgs);
3153  return (_Res);
3154  }
back_inserter
back_insert_iterator< _Container > back_inserter(_Container &_Cont)
Definition: iterator:69
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:3031
basic_string
Definition: xstring:21
_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 
)
3164  { // search and replace, string result, NTBS target, NTBS format
3165  basic_string<_Elem> _Res;
3166  const basic_string<_Elem> _Str(_Pstr);
3167  const basic_string<_Elem> _Fmt(_Ptr);
3168  _STD regex_replace(_STD back_inserter(_Res), _Str.begin(), _Str.end(),
3169  _Re, _Fmt, _Flgs);
3170  return (_Res);
3171  }
back_inserter
back_insert_iterator< _Container > back_inserter(_Container &_Cont)
Definition: iterator:69
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:3031
basic_string
Definition: xstring:21
_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
2886  { // search for regular expression match in target text
2887  _DEBUG_RANGE(_First, _Last);
2888  return (_Regex_search1(_First, _Last, &_Matches, _Re, _Flgs, _First));
2889  }
_DEBUG_RANGE
#define _DEBUG_RANGE(first, last)
Definition: xutility:822
_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:2834
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
2898  { // search for regular expression match in target text
2899  _DEBUG_RANGE(_First, _Last);
2900  return (_Regex_search1(_Unchecked(_First), _Unchecked(_Last),
2901  static_cast<match_results<decltype(_Unchecked(_First))> *>(0), _Re,
2902  _Flgs | regex_constants::match_any, _Unchecked(_First)));
2903  }
_DEBUG_RANGE
#define _DEBUG_RANGE(first, last)
Definition: xutility:822
_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:2834
regex_constants::match_any
Definition: regex:123
match_results
Definition: regex:1132
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
2911  { // search for regular expression match in target text
2912  const _Elem *_Last = _Str + char_traits<_Elem>::length(_Str);
2913  return (_Regex_search1(_Str, _Last,
2914  static_cast<match_results<const _Elem *> *>(0), _Re,
2915  _Flgs | regex_constants::match_any, _Str));
2916  }
_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:2834
regex_constants::match_any
Definition: regex:123
match_results
Definition: regex:1132
cliext::_Last
_FwdIt _Last
Definition: algorithm:1936
_Char_traits< _Elem, long >::length
static size_t __CLRCALL_OR_CDECL length(_In_z_ const _Elem *_First)
Definition: iosfwd:151
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
2926  { // search for regular expression match in target text
2927  const _Elem *_Last = _Str + char_traits<_Elem>::length(_Str);
2928  return (_Regex_search1(_Str, _Last, &_Matches, _Re, _Flgs, _Str));
2929  }
_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:2834
cliext::_Last
_FwdIt _Last
Definition: algorithm:1936
_Char_traits< _Elem, long >::length
static size_t __CLRCALL_OR_CDECL length(_In_z_ const _Elem *_First)
Definition: iosfwd:151
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
2943  { // search for regular expression match in target text
2944  return (_Regex_search1(_Str.begin(), _Str.end(),
2945  &_Matches, _Re, _Flgs, _Str.begin()));
2946  }
_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:2834
basic_string::end
iterator end() _NOEXCEPT
Definition: xstring:1605
basic_string::begin
iterator begin() _NOEXCEPT
Definition: xstring:1593
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
2970  { // search for regular expression match in target text
2971  typedef typename basic_string<_Elem, _StTraits, _StAlloc>
2972  ::const_pointer _Iter;
2973 
2974  _Iter _First = _Str.c_str();
2975  _Iter _Last = _First + _Str.size();
2976  return (_Regex_search1(_First, _Last,
2977  static_cast<match_results<_Iter> *>(0), _Re,
2978  _Flgs | regex_constants::match_any, _First));
2979  }
_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:2834
regex_constants::match_any
Definition: regex:123
match_results
Definition: regex:1132
basic_string::c_str
const _Elem * c_str() const _NOEXCEPT
Definition: xstring:1741
basic_string::size
size_type size() const _NOEXCEPT
Definition: xstring:1763
basic_string
Definition: xstring:21
cliext::_Last
_FwdIt _Last
Definition: algorithm:1936
template<class _Elem , class _RxTraits >
void swap ( basic_regex< _Elem, _RxTraits > &  _Left,
basic_regex< _Elem, _RxTraits > &  _Right 
)
2577  { // exchange contents of _Left with _Right
2578  _Left.swap(_Right);
2579  }
basic_regex::swap
void swap(_Myt &_Right) _THROW0()
Definition: regex:2500
template<class _BidIt , class _Alloc >
void swap ( match_results< _BidIt, _Alloc > &  _Left,
match_results< _BidIt, _Alloc > &  _Right 
)
2585  { // exchange contents of _Left with _Right
2586  _Left.swap(_Right);
2587  }
match_results::swap
void swap(match_results &_Right)
Definition: regex:1397

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 Mon Jul 24 2017 18:15:36 for STLdoc by   doxygen 1.8.8