_Matcher< _BidIt, _Elem, _RxTraits, _It > Class Template Reference

Public Member Functions
	_Matcher (_It _Pfirst, _It _Plast, const _RxTraits &_Tr, _Root_node *_Re, int _Nx, regex_constants::syntax_option_type _Sf, regex_constants::match_flag_type _Mf)
void	_Setf (regex_constants::match_flag_type _Mf)
void	_Clearf (regex_constants::match_flag_type _Mf)
template<class _Alloc >
bool	_Match (_It _Pfirst, match_results< _BidIt, _Alloc > *_Matches, bool _Full_match)
template<class _Alloc >
bool	_Match (match_results< _BidIt, _Alloc > *_Matches, bool _Full_match)
_BidIt	_Skip (_BidIt, _BidIt, _Node_base *=0)

Private Member Functions
bool	_Do_if (_Node_if *)
bool	_Do_rep0 (_Node_rep *, bool)
bool	_Do_rep (_Node_rep *, bool, int)
bool	_Is_wc (_It, int)
bool	_Do_class (_Node_base *)
bool	_Match_pat (_Node_base *)
bool	_Better_match ()
_Matcher &	operator= (const _Matcher &)

Private Attributes
_Tgt_state_t< _It >	_Tgt_state
_Tgt_state_t< _It >	_Res
vector< _Loop_vals_t >	_Loop_vals
_It	_Begin
_It	_End
_It	_First
_Node_base *	_Rep
regex_constants::syntax_option_type	_Sflags
regex_constants::match_flag_type	_Mflags
bool	_Matched
bool	_Cap
int	_Ncap
bool	_Longest
const _RxTraits &	_Traits
bool	_Full
long	_Max_complexity_count
long	_Max_stack_count

Constructor & Destructor Documentation

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

_Matcher< _BidIt, _Elem, _RxTraits, _It >::_Matcher ( _It  _Pfirst, _It  _Plast, const _RxTraits &  _Tr, _Root_node *  _Re, int  _Nx, regex_constants::syntax_option_type  _Sf, regex_constants::match_flag_type  _Mf  )

inline

            : _First(_Pfirst), _End(_Plast), _Traits(_Tr), _Rep(_Re),
                _Sflags(_Sf), _Mflags(_Mf), _Matched(false),
                _Ncap(_Nx),
                _Longest((_Re->_Flags & _Fl_longest)
                    && !(_Mf & regex_constants::match_any))
        {   // construct
        _Loop_vals.resize(_Re->_Loops);
        _DEBUG_RANGE(_Pfirst, _Plast);
        }

Member Function Documentation

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

bool _Matcher< _BidIt, _Elem, _RxTraits, _It >::_Better_match ( )

inlineprivate

    {   // check for better match under UNIX rules
    int _Ix;

    for (_Ix = 0; _Ix < _Ncap; ++_Ix)
        {   // check each capture group
        if (!_Res._Grp_valid[_Ix] || !_Tgt_state._Grp_valid[_Ix])
            ;
        else if (_Res._Grps[_Ix]._Begin
            != _Tgt_state._Grps[_Ix]._Begin)
            return (_STD distance(_Begin, _Res._Grps[_Ix]._Begin)
                < _STD distance(_Begin, _Tgt_state._Grps[_Ix]._Begin));
        else if (_Res._Grps[_Ix]._End
            != _Tgt_state._Grps[_Ix]._End)
            return (_STD distance(_Begin, _Res._Grps[_Ix]._End)
                < _STD distance(_Begin, _Tgt_state._Grps[_Ix]._End));
        }
    return (false);
    }

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

void _Matcher< _BidIt, _Elem, _RxTraits, _It >::_Clearf ( regex_constants::match_flag_type  _Mf )

inline

        {   // clear specified flags
        _Mflags &= ~_Mf;
        }

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

bool _Matcher< _BidIt, _Elem, _RxTraits, _It >::_Do_class ( _Node_base *  _Nx )

inlineprivate

    {   // apply bracket expression
    static int _Max = _Bmp_max; // to quiet diagnostics
    static int _Min = 0;

    bool _Found;
    _Elem _Ch = *_Tgt_state._Cur;
    if (_Sflags & regex_constants::icase)
        _Ch = _Traits.translate_nocase(_Ch);
    _It _Res = _Tgt_state._Cur;
    ++_Res;
    _It _Resx;
    _Node_class<_Elem, _RxTraits> *_Node =
        (_Node_class<_Elem, _RxTraits> *)_Nx;
    if (_Node->_Coll
        && (_Resx = _Lookup_coll(_Tgt_state._Cur, _End, _Node->_Coll))
            != _Tgt_state._Cur)
        {   // check for collation element
        _Res = _Resx;
        _Found = true;
        }
    else if (_Node->_Ranges
        && (_Lookup_range((_Elem)(_Sflags & regex_constants::collate
            ? (int)_Traits.translate(_Ch) : (int)_Ch), _Node->_Ranges)))
        _Found = true;
    else if (_Min <= _Ch && _Ch < _Max)
        _Found = _Node->_Small && _Node->_Small->_Find(_Ch);
    else if (_Node->_Large
        && _STD find(_Node->_Large->_Str(),
            _Node->_Large->_Str() + _Node->_Large->_Size(), _Ch)
                != _Node->_Large->_Str() + _Node->_Large->_Size())
        _Found = true;
    else if (_Node->_Classes != 0 && _Traits.isctype(_Ch, _Node->_Classes))
        _Found = true;
    else if (_Node->_Equiv && _Lookup_equiv(_Ch, _Node->_Equiv, _Traits))
        _Found = true;
    else
        _Found = false;
    if (_Found == (_Node->_Flags & _Fl_negate))
        return (false);
    else
        {   // record result
        _Tgt_state._Cur = _Res;
        return (true);
        }
    }

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

bool _Matcher< _BidIt, _Elem, _RxTraits, _It >::_Do_if ( _Node_if *  _Node )

inlineprivate

    {   // apply if node
    _Tgt_state_t<_It> _St = _Tgt_state;
    _Tgt_state_t<_It> _Final = _Tgt_state;
    bool _Matched = false;
    int _Final_len = -1;

    while (_Node)
        {   // process one branch of if
        _Tgt_state = _St;
        if (!_Match_pat(_Node->_Next))
            ;
        else if (!_Longest)
            return (true);
        else
            {   // record match
            int _Len = (int)_STD distance(_St._Cur, _Tgt_state._Cur);
            if (_Final_len < _Len)
                {   // memorize longest so far
                _Final = _Tgt_state;
                _Final_len = _Len;
                }
            _Matched = true;
            }
        _Node = _Node->_Child;
        }
    _Tgt_state = _Matched ? _Final : _St;
    return (_Matched);
    }

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

bool _Matcher< _BidIt, _Elem, _RxTraits, _It >::_Do_rep ( _Node_rep *  _Node, bool  _Greedy, int  _Init_idx  )

inlineprivate

    {   // apply repetition
    if (_Node->_Simple_loop < 0)
        {   // first time, determine if loop is simple
        _Node_base *_Nx = _Node->_Next;
        for (; _Nx->_Kind != _N_end_rep; _Nx = _Nx->_Next)
            if (_Nx->_Kind == _N_if || _Nx->_Kind == _N_rep)
                break;
        _Node->_Simple_loop = _Nx->_Kind == _N_end_rep ? 1 : 0;
        }
    if (0 <  _Node->_Simple_loop)
        return (_Do_rep0(_Node, _Greedy));

    bool _Matched = false;
    _Tgt_state_t<_It> _St = _Tgt_state;
    _Loop_vals_t *_Psav = &_Loop_vals[_Node->_Loop_number];
    int _Loop_idx_sav = _Psav->_Loop_idx;
    _It *_Loop_iter_sav = (_It *)_Psav->_Loop_iter;
    _It _Cur_iter = _Tgt_state._Cur;

    bool _Progress = _Init_idx == 0 || *_Loop_iter_sav != _Cur_iter;

    if (0 <= _Node->_Max && _Node->_Max <= _Init_idx)
        _Matched = _Match_pat(_Node->_End_rep->_Next);  // reps done, try tail
    else if (_Init_idx < _Node->_Min)
        {   // try a required rep
        if (!_Progress)
            _Matched = _Match_pat(_Node->_End_rep->_Next);  // empty, try tail
        else
            {   // try another required match
            _Psav->_Loop_idx = _Init_idx + 1;
            _Psav->_Loop_iter = &_Cur_iter;
            _Matched = _Match_pat(_Node->_Next);
            }
        }
    else if (!_Greedy)
        {   // not greedy, favor minimum number of reps
        _Matched = _Match_pat(_Node->_End_rep->_Next);
        if (!_Matched && _Progress)
            {   // tail failed, try another rep
            _Tgt_state = _St;
            _Psav->_Loop_idx = _Init_idx + 1;
            _Psav->_Loop_iter = &_Cur_iter;
            _Matched = _Match_pat(_Node->_Next);
            }
        }
    else
        {   // greedy, favor maximum number of reps
        if (_Progress)
            {   // try another rep
            _Psav->_Loop_idx = _Init_idx + 1;
            _Psav->_Loop_iter = &_Cur_iter;
            _Matched = _Match_pat(_Node->_Next);
            }
        if (!_Progress && 1 < _Init_idx)
            ;
        else if (!_Matched)
            {   // rep failed, try tail
            _Psav->_Loop_idx = _Loop_idx_sav;
            _Psav->_Loop_iter = _Loop_iter_sav;
            _Tgt_state = _St;
            _Matched = _Match_pat(_Node->_End_rep->_Next);
            }
        }

    if (!_Matched)
        _Tgt_state = _St;
    _Psav->_Loop_idx = _Loop_idx_sav;
    _Psav->_Loop_iter = _Loop_iter_sav;
    return (_Matched);
    }

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

bool _Matcher< _BidIt, _Elem, _RxTraits, _It >::_Do_rep0 ( _Node_rep *  _Node, bool  _Greedy  )

inlineprivate

    {   // apply repetition to loop with no nested if/do
    int _Ix = 0;
    _Tgt_state_t<_It> _St = _Tgt_state;

    for (; _Ix < _Node->_Min; ++_Ix)
        {   // do minimum number of reps
        _It _Cur = _Tgt_state._Cur;
        if (!_Match_pat(_Node->_Next))
            {   // didn't match minimum number of reps, fail
            _Tgt_state = _St;
            return (false);
            }
        else if (_Cur == _Tgt_state._Cur)
            _Ix = _Node->_Min - 1;  // skip matches that don't change state
        }

    _Tgt_state_t<_It> _Final = _Tgt_state;
    bool _Matched = false;
    _It _Saved_pos = _Tgt_state._Cur;

    if (!_Match_pat(_Node->_End_rep->_Next))
        ;   // no full match yet
    else if (!_Greedy)
        return (true);  // go with current match
    else
        {   // record an acceptable match and continue
        _Final = _Tgt_state;
        _Matched = true;
        }

    while (_Node->_Max == -1 || _Ix++ < _Node->_Max)
        {   // try another rep/tail match
        _Tgt_state._Cur = _Saved_pos;
        _Tgt_state._Grp_valid = _St._Grp_valid;
        if (!_Match_pat(_Node->_Next))
            break;  // rep match failed, quit loop

        _It _Mid = _Tgt_state._Cur;
        if (!_Match_pat(_Node->_End_rep->_Next))
            ;   // tail match failed, continue
        else if (!_Greedy)
            return (true);  // go with current match
        else
            {   // record match and continue
            _Final = _Tgt_state;
            _Matched = true;
            }

        if (_Saved_pos == _Mid)
            break;  // rep match ate no additional elements, quit loop
        _Saved_pos = _Mid;
        }

    _Tgt_state = _Matched ? _Final : _St;
    return (_Matched);
    }

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

bool _Matcher< _BidIt, _Elem, _RxTraits, _It >::_Is_wc ( _It  _Ch0, int  _Offset  )

inlineprivate

    {   // check for word boundary
    if ((_Offset == -1
        && _Ch0 == _Begin
        && !(_Mflags & regex_constants::match_prev_avail))
            || (_Offset == 0 && _Ch0 == _End))
        return (false);
    else
        {   // test for word char
        _Elem _Ch = (_Offset ? *--_Ch0 : *_Ch0);

        return (_Ch == (char)_Ch    // assume L'x' == 'x'
            && strchr("abcdefghijklmnopqrstuvwxyz"
                "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
                "0123456789_", _Ch) != 0);
        }
    }

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

template<class _Alloc >

bool _Matcher< _BidIt, _Elem, _RxTraits, _It >::_Match ( _It  _Pfirst, match_results< _BidIt, _Alloc > *  _Matches, bool  _Full_match  )

inline

        {   // try to match
        _First = _Pfirst;
        return (_Match(_Matches, _Full_match));
        }

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

template<class _Alloc >

bool _Matcher< _BidIt, _Elem, _RxTraits, _It >::_Match ( match_results< _BidIt, _Alloc > *  _Matches, bool  _Full_match  )

inline

        {   // try to match
        _Begin = _First;
        _Tgt_state._Cur = _First;
        _Tgt_state._Grp_valid.resize(_Ncap);
        _Tgt_state._Grps.resize(_Ncap);
        _Cap = _Matches != 0;
        _Full = _Full_match;
        _Max_complexity_count = _REGEX_MAX_COMPLEXITY_COUNT;
        _Max_stack_count = _REGEX_MAX_STACK_COUNT;

        _Matched = false;

        if (_Match_pat(_Rep))
            ;
        else if ((_Mflags & regex_constants::_Match_partial) != 0
            && _Tgt_state._Cur == _End && _First != _End)
            {   // record successful partial match
            _Res = _Tgt_state;
            _Matched = true;
            }
        else
            return (false);
        if (_Matches)
            {   // copy results to _Matches
            _Matches->_Resize(_Ncap);
            for (int _Idx = 0; _Idx < _Ncap; ++_Idx)
                {   // copy submatch _Idx
                if (_Res._Grp_valid[_Idx])
                    {   // copy successful match
                    _Matches->_At(_Idx).matched = true;
                    _Matches->_At(_Idx).first = _Res._Grps[_Idx]._Begin;
                    _Matches->_At(_Idx).second = _Res._Grps[_Idx]._End;
                    }
                else
                    {   // copy failed match
                    _Matches->_At(_Idx).matched = false;
                    _Matches->_At(_Idx).first = _End;
                    _Matches->_At(_Idx).second = _End;
                    }
                }
            _Matches->_Org = _Begin;
            _Matches->_Pfx().matched = true;
            _Matches->_Pfx().first = _Begin;
            _Matches->_Pfx().second = _Matches->_At(0).first;

            _Matches->_Sfx().matched = true;
            _Matches->_Sfx().first = _Matches->_At(0).second;
            _Matches->_Sfx().second = _End;

            _Matches->_Null().first = _End;
            _Matches->_Null().second = _End;

            _Matches->_Ready = true;
            }
        return (true);
        }

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

bool _Matcher< _BidIt, _Elem, _RxTraits, _It >::_Match_pat ( _Node_base *  _Nx )

inlineprivate

    {   // check for match
    if (0 < _Max_stack_count && --_Max_stack_count <= 0)
        _Xregex_error(regex_constants::error_stack);
    if (0 < _Max_complexity_count && --_Max_complexity_count <= 0)
        _Xregex_error(regex_constants::error_complexity);

    bool _Failed = false;
    while (_Nx != 0)
        {   // match current node
        switch (_Nx->_Kind)
            {   // handle current node's type
            case _N_nop:
                break;

            case _N_bol:
                if ((_Mflags & (regex_constants::match_not_bol
                    | regex_constants::match_prev_avail))
                        == regex_constants::match_not_bol)
                    _Failed = true;
                else if (_Mflags & regex_constants::match_prev_avail
                    || _Tgt_state._Cur != _Begin)
                    {   // check for preceding newline
                    _It _Tmp = _Tgt_state._Cur;
                    _Failed = *--_Tmp != _Meta_nl;
                    }
                break;

            case _N_eol:
                if ((_Mflags & regex_constants::match_not_eol) != 0
                    || (_Tgt_state._Cur != _End
                        && *_Tgt_state._Cur != _Meta_nl))
                    _Failed = true;
                break;

            case _N_wbound:
                {   // check for word boundary
                bool _Is_bound;
                if (((_Mflags & regex_constants::match_not_bow)
                    && _Tgt_state._Cur == _Begin)
                    || ((_Mflags & regex_constants::match_not_eow)
                        && _Tgt_state._Cur == _End))
                    _Is_bound = false;
                else
                    _Is_bound = _Is_wc(_Tgt_state._Cur, -1)
                        != _Is_wc(_Tgt_state._Cur, 0);
                bool _Neg = (_Nx->_Flags & _Fl_negate) != 0;
                if (_Is_bound == _Neg)
                    _Failed = true;
                break;
                }

            case _N_dot:
                if (_Tgt_state._Cur == _End
                    || *_Tgt_state._Cur == _Meta_nl
                    || *_Tgt_state._Cur == _Meta_cr)
                    _Failed = true;
                else
                    ++_Tgt_state._Cur;
                break;

            case _N_str:
                {   // check for string match
                _Node_str<_Elem> *_Node = (_Node_str<_Elem> *)_Nx;
                _It _Res;
                if ((_Res = _Compare(_Tgt_state._Cur, _End,
                    _Node->_Data._Str(),
                    _Node->_Data._Str() + _Node->_Data._Size(),
                    _Traits, _Sflags,
                    (_Mflags & regex_constants::_Match_partial) != 0))
                        != _Tgt_state._Cur)
                    _Tgt_state._Cur = _Res;
                else
                    _Failed = true;
                break;
                }

            case _N_class:
                {   // check for bracket expression match
                _Failed = _Tgt_state._Cur == _End
                    || !_Do_class(_Nx);
                break;
                }

            case _N_group:
                break;

            case _N_end_group:
                break;

            case _N_neg_assert:
            case _N_assert:
                {   // check assert
                _It _Ch = _Tgt_state._Cur;
                bool _Neg = _Nx->_Kind == _N_neg_assert;
                _Bt_state_t<_It> _St = _Tgt_state;
                if (_Match_pat(((_Node_assert *)_Nx)->_Child) == _Neg)
                    {   // restore initial state and indicate failure
                    _Tgt_state = _St;
                    _Failed = true;
                    }
                else
                    _Tgt_state._Cur = _Ch;
                break;
                }

            case _N_end_assert:
                _Nx = 0;
                break;

            case _N_capture:
                {   // record current position
                _Node_capture *_Node = (_Node_capture *)_Nx;
                _Tgt_state._Grps[_Node->_Idx]._Begin = _Tgt_state._Cur;
                for (size_t _Idx = _Tgt_state._Grp_valid.size();
                    _Node->_Idx < _Idx; )
                    _Tgt_state._Grp_valid[--_Idx] = false;
                break;
                }

            case _N_end_capture:
                {   // record successful capture
                _Node_end_group *_Node = (_Node_end_group *)_Nx;
                _Node_capture *_Node0 = (_Node_capture *)_Node->_Back;
                if (_Cap || _Node0->_Idx != 0)
                    {   // update capture data
                    _Tgt_state._Grp_valid[_Node0->_Idx] = true;
                    _Tgt_state._Grps[_Node0->_Idx]._End = _Tgt_state._Cur;
                    }
                break;
                }

            case _N_back:
                {   // check back reference
                _Node_back *_Node = (_Node_back *)_Nx;
                if (_Tgt_state._Grp_valid[_Node->_Idx])
                    {   // check for match
                    _It _Res = _Tgt_state._Cur;
                    _It _Bx = _Tgt_state._Grps[_Node->_Idx]._Begin;
                    _It _Ex = _Tgt_state._Grps[_Node->_Idx]._End;
                    if (_Bx != _Ex  // _Bx == _Ex for zero-length match
                        && (_Res = _Compare(_Tgt_state._Cur, _End,
                            _Bx, _Ex, _Traits, _Sflags,
                            (_Mflags & regex_constants::_Match_partial) != 0))
                                == _Tgt_state._Cur)
                        _Failed = true;
                    else
                        _Tgt_state._Cur = _Res;
                    }
                break;
                }

            case _N_if:
                if (!_Do_if((_Node_if *)_Nx))
                    _Failed = true;
                _Nx = 0;
                break;

            case _N_endif:
                break;

            case _N_rep:
                if (!_Do_rep((_Node_rep *)_Nx,
                    (_Nx->_Flags & _Fl_greedy) != 0, 0))
                    _Failed = true;
                _Nx = 0;
                break;

            case _N_end_rep:
                {   // return at end of loop
                _Node_rep *_Nr = ((_Node_end_rep *)_Nx)->_Begin_rep;
                _Loop_vals_t *_Psav = &_Loop_vals[_Nr->_Loop_number];

                if (_Nr->_Simple_loop == 0 && !_Do_rep(_Nr,
                    (_Nr->_Flags & _Fl_greedy) != 0, _Psav->_Loop_idx))
                    _Failed = true; // recurse only if loop contains if/do
                _Nx = 0;
                break;
                }

            case _N_begin:
                break;

            case _N_end:
                if (((_Mflags & (regex_constants::match_not_null
                        | regex_constants::_Match_not_null))
                    && _Begin == _Tgt_state._Cur)
                        || (_Full && _Tgt_state._Cur != _End))
                    _Failed = true;
                else if (!_Matched || _Better_match())
                    {   // record successful match
                    _Res = _Tgt_state;
                    _Matched = true;
                    }
                _Nx = 0;
                break;

            default:
                _Xregex_error(regex_constants::error_parse);
            }

        if (_Failed)
            _Nx = 0;
        else if (_Nx)
            _Nx = _Nx->_Next;
        }

    if (0 < _Max_stack_count)
        ++_Max_stack_count;
    return (!_Failed);
    }

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

void _Matcher< _BidIt, _Elem, _RxTraits, _It >::_Setf ( regex_constants::match_flag_type  _Mf )

inline

        {   // set specified flags
        _Mflags |= _Mf;
        }

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

_BidIt _Matcher< _BidIt, _Elem, _RxTraits, _It >::_Skip ( _BidIt  _First, _BidIt  _Last, _Node_base *  _Node_arg = 0  )

inline

    {   // skip until possible match
    _Node_base *_Nx = _Node_arg != 0 ? _Node_arg : _Rep;

    while (_First != _Last && _Nx != 0)
        {   // check current node
        switch (_Nx->_Kind)
            {   // handle current node's type
            case _N_nop:
                break;

            case _N_bol:
                {   // check for embedded newline
                if (_Mflags & regex_constants::match_not_bol)
                    return (_Last);
                for (; _First != _Last; ++_First)
                    {   // look for character following meta newline
                    _It _Prev = _First;
                    if (*--_Prev == _Meta_nl)
                        break;
                    }
                return (_First);
                }

            case _N_eol:
                if (_Mflags & regex_constants::match_not_eol)
                    return (_Last);
                for (; _First != _Last; ++_First)
                    if (*_First == _Meta_nl)
                        break;
                return (_First);

//          case _N_wbound:
//          case _N_dot:

            case _N_str:
                {   // check for string match
                _Node_str<_Elem> *_Node = (_Node_str<_Elem> *)_Nx;
                for (; _First != _Last; ++_First)
                    {   // look for starting match
                    _BidIt _Next = _First;
                    if (_Compare(_First, ++_Next,
                        _Node->_Data._Str(),
                        _Node->_Data._Str() + 1,
                        _Traits, _Sflags,
                        (_Mflags & regex_constants::_Match_partial) != 0)
                            != _First)
                        break;
                    }
                return (_First);
                }

            case _N_class:
                {   // check for string match
                for (; _First != _Last; ++_First)
                    {   // look for starting match
                    static int _Max = _Bmp_max; // to quiet diagnostics
                    static int _Min = 0;

                    bool _Found;
                    _Elem _Ch = *_First;
                    _Node_class<_Elem, _RxTraits> *_Node =
                        (_Node_class<_Elem, _RxTraits> *)_Nx;
                    _It _Next = _First;
                    ++_Next;

                    if (_Node->_Coll
                        && _Lookup_coll(_First, _Next, _Node->_Coll)
                            != _First)
                        _Found = true;
                    else if (_Node->_Ranges
                        && (_Lookup_range(
                            (_Elem)(_Sflags & regex_constants::collate
                                ? (int)_Traits.translate(_Ch)
                                : (int)_Ch), _Node->_Ranges)))
                        _Found = true;
                    else if (_Min <= _Ch && _Ch < _Max)
                        _Found = _Node->_Small && _Node->_Small->_Find(_Ch);
                    else if (_Node->_Large
                        && _STD find(_Node->_Large->_Str(),
                            _Node->_Large->_Str() + _Node->_Large->_Size(),
                                _Ch)
                            != _Node->_Large->_Str() + _Node->_Large->_Size())
                        _Found = true;
                    else if (_Node->_Classes
                        && _Traits.isctype(_Ch, _Node->_Classes))
                        _Found = true;
                    else if (_Node->_Equiv
                        && _Lookup_equiv(_Ch, _Node->_Equiv, _Traits))
                        _Found = true;
                    else
                        _Found = false;

                    if (_Found != (_Node->_Flags & _Fl_negate))
                        return (_First);
                    }
                }
                return (_First);

            case _N_group:
                break;

            case _N_end_group:
                break;

//          case _N_neg_assert:
//          case _N_assert:

            case _N_end_assert:
                _Nx = 0;
                break;

            case _N_capture:
                break;

            case _N_end_capture:
                break;

//          case _N_back:

            case _N_if:
                {   // check for soonest string match
                _Node_if *_Node = (_Node_if *)_Nx;

                for (; _First != _Last && _Node != 0; _Node = _Node->_Child)
                    _Last = _Skip(_First, _Last, _Node->_Next);
                return (_Last);
                }

//          case _N_endif:
//          case _N_rep:
//          case _N_end_rep:

            case _N_begin:
                break;

            case _N_end:
                _Nx = 0;
                break;

            default:
                return (_First);
            }
        if (_Nx)
            _Nx = _Nx->_Next;
        }
    return (_First);
    }

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

_Matcher& _Matcher< _BidIt, _Elem, _RxTraits, _It >::operator= ( const _Matcher< _BidIt, _Elem, _RxTraits, _It > &  )

private

Member Data Documentation

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

_It _Matcher< _BidIt, _Elem, _RxTraits, _It >::_Begin

private

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

bool _Matcher< _BidIt, _Elem, _RxTraits, _It >::_Cap

private

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

_It _Matcher< _BidIt, _Elem, _RxTraits, _It >::_End

private

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

_It _Matcher< _BidIt, _Elem, _RxTraits, _It >::_First

private

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

bool _Matcher< _BidIt, _Elem, _RxTraits, _It >::_Full

private

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

bool _Matcher< _BidIt, _Elem, _RxTraits, _It >::_Longest

private

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

vector<_Loop_vals_t> _Matcher< _BidIt, _Elem, _RxTraits, _It >::_Loop_vals

private

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

bool _Matcher< _BidIt, _Elem, _RxTraits, _It >::_Matched

private

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

long _Matcher< _BidIt, _Elem, _RxTraits, _It >::_Max_complexity_count

private

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

long _Matcher< _BidIt, _Elem, _RxTraits, _It >::_Max_stack_count

private

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

regex_constants::match_flag_type _Matcher< _BidIt, _Elem, _RxTraits, _It >::_Mflags

private

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

int _Matcher< _BidIt, _Elem, _RxTraits, _It >::_Ncap

private

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

_Node_base* _Matcher< _BidIt, _Elem, _RxTraits, _It >::_Rep

private

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

_Tgt_state_t<_It> _Matcher< _BidIt, _Elem, _RxTraits, _It >::_Res

private

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

regex_constants::syntax_option_type _Matcher< _BidIt, _Elem, _RxTraits, _It >::_Sflags

private

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

_Tgt_state_t<_It> _Matcher< _BidIt, _Elem, _RxTraits, _It >::_Tgt_state

private

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

const _RxTraits& _Matcher< _BidIt, _Elem, _RxTraits, _It >::_Traits

private

---

The documentation for this class was generated from the following file:

• VS2013/inc/regex