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

Public Member Functions
	_Matcher (_It _Pfirst, _It _Plast, const _RxTraits &_Tr, _Root_node *_Re, unsigned 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	_Do_class (_Node_base *)
bool	_Match_pat (_Node_base *)
bool	_Better_match ()
bool	_Is_wbound () const
unsigned int	_Get_ncap () const
_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, unsigned 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(static_cast<int>(_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
    for (unsigned int _Ix = 0; _Ix < _Get_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
    bool _Found;
    typename _RxTraits::_Uelem _Ch = *_Tgt_state._Cur;
    if (_Sflags & regex_constants::icase)
        _Ch = _Traits.translate_nocase(_Ch);
    _It _Res0 = _Tgt_state._Cur;
    ++_Res0;
    _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
        _Res0 = _Resx;
        _Found = true;
        }
    else if (_Node->_Ranges
        && (_Lookup_range((typename _RxTraits::_Uelem)
            (_Sflags & regex_constants::collate
                ? _Traits.translate(_Ch)
                : _Ch), _Node->_Ranges)))
        _Found = true;
    else if (_Ch < _Bmp_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 = _Res0;
        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;

    // look for the first match
    for (; _Node; _Node = _Node->_Child)
        {   // process one branch of if
        _Tgt_state = _St; // rewind to where the alternation starts in input
        if (_Match_pat(_Node->_Next)) // try to match this branch
            break;
        }

    // if none of the if branches matched, fail to match
    if (!_Node)
        return (false);

    // if we aren't looking for the longest match, that's it
    if (!_Longest)
        return (true);

    // see if there is a longer match
    _Tgt_state_t<_It> _Final = _Tgt_state;
    size_t _Final_len = _STD distance(_St._Cur, _Tgt_state._Cur);
    for (;;)
        {   // process one branch of if
        _Node = _Node->_Child;
        if (!_Node)
            break;

        _Tgt_state = _St;
        if (_Match_pat(_Node->_Next))
            {   // record match if it is longer
            size_t _Len = _STD distance(_St._Cur, _Tgt_state._Cur);
            if (_Final_len < _Len)
                {   // memorize longest so far
                _Final = _Tgt_state;
                _Final_len = _Len;
                }
            }
        }

    // set the input end to the longest match
    _Tgt_state = _Final;
    return (true);
    }

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 == 1)
        return (_Do_rep0(_Node, _Greedy));

    bool _Matched0 = 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)
        _Matched0 = _Match_pat(_Node->_End_rep->_Next); // reps done, try tail
    else if (_Init_idx < _Node->_Min)
        {   // try a required rep
        if (!_Progress)
            _Matched0 = _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;
            _Matched0 = _Match_pat(_Node->_Next);
            }
        }
    else if (!_Greedy)
        {   // not greedy, favor minimum number of reps
        _Matched0 = _Match_pat(_Node->_End_rep->_Next);
        if (!_Matched0 && _Progress)
            {   // tail failed, try another rep
            _Tgt_state = _St;
            _Psav->_Loop_idx = _Init_idx + 1;
            _Psav->_Loop_iter = &_Cur_iter;
            _Matched0 = _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;
            _Matched0 = _Match_pat(_Node->_Next);
            }
        if (!_Progress && 1 < _Init_idx)
            ;
        else if (!_Matched0)
            {   // rep failed, try tail
            _Psav->_Loop_idx = _Loop_idx_sav;
            _Psav->_Loop_iter = _Loop_iter_sav;
            _Tgt_state = _St;
            _Matched0 = _Match_pat(_Node->_End_rep->_Next);
            }
        }

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

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 _Matched0 = 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;
        _Matched0 = 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;
            _Matched0 = true;
            }

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

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

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

unsigned int _Matcher< _BidIt, _Elem, _RxTraits, _It >::_Get_ncap ( ) const

inlineprivate

    {
    return (static_cast<unsigned int>(_Ncap));
    }

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

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

inlineprivate

    {   // test if _Tgt_state._Cur is a word boundary
    if ((_Mflags & regex_constants::match_prev_avail)
        || _Tgt_state._Cur != _Begin)
        {   // if --_Cur is valid, check for preceding word character
        if (_Tgt_state._Cur == _End)
            return ((_Mflags & regex_constants::match_not_eow) == 0 && _Is_word(*_STD prev(_Tgt_state._Cur)));
        else
            return (_Is_word(*_STD prev(_Tgt_state._Cur)) != _Is_word(*_Tgt_state._Cur));
        }
    else
        {   // --_Cur is not valid
        if (_Tgt_state._Cur == _End)
            return ((_Mflags & (regex_constants::match_not_bow | regex_constants::match_not_eow)) == 0);
        else
            return ((_Mflags & regex_constants::match_not_bow) == 0 && _Is_word(*_Tgt_state._Cur));
        }
    }

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
        if (_Matches)
            {   // clear _Matches before doing work
            _Matches->_Ready = true;
            _Matches->_Resize(0);
            }

        _Begin = _First;
        _Tgt_state._Cur = _First;
        _Tgt_state._Grp_valid.resize(_Get_ncap());
        _Tgt_state._Grps.resize(_Get_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))
            return (false);

        if (_Matches)
            {   // copy results to _Matches
            _Matches->_Resize(_Get_ncap());
            for (unsigned int _Idx = 0; _Idx < _Get_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().first = _Begin;
            _Matches->_Pfx().second = _Matches->_At(0).first;
            _Matches->_Pfx().matched =
                _Matches->_Pfx().first != _Matches->_Pfx().second;

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

            _Matches->_Null().first = _End;
            _Matches->_Null().second = _End;
            }
        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_prev_avail)
                    || _Tgt_state._Cur != _Begin)
                    {   // if --_Cur is valid, check for preceding newline
                    _Failed = *_STD prev(_Tgt_state._Cur) != _Meta_nl;
                    }
                else
                    _Failed = (_Mflags & regex_constants::match_not_bol) != 0;
                break;

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

            case _N_wbound:
                _Failed = _Is_wbound() == ((_Nx->_Flags & _Fl_negate) != 0);
                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 _Res0;
                if ((_Res0 = _Compare(_Tgt_state._Cur, _End,
                    _Node->_Data._Str(),
                    _Node->_Data._Str() + _Node->_Data._Size(),
                    _Traits, _Sflags))
                        != _Tgt_state._Cur)
                    _Tgt_state._Cur = _Res0;
                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 _Res0 = _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
                        && (_Res0 = _Compare(_Tgt_state._Cur, _End,
                            _Bx, _Ex, _Traits, _Sflags))
                                == _Tgt_state._Cur)
                        _Failed = true;
                    else
                        _Tgt_state._Cur = _Res0;
                    }
                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_arg, _BidIt  _Last, _Node_base *  _Node_arg = 0  )

inline

    {   // skip until possible match
        // assumes --_First_arg is valid
    _Node_base *_Nx = _Node_arg != 0 ? _Node_arg : _Rep;

    while (_First_arg != _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
                    // return iterator to character just after the newline; for input like "\nabc"
                    // matching "^abc", _First_arg could be pointing at 'a', so we need to check
                    // --_First_arg for '\n'
                if (*_STD prev(_First_arg) != _Meta_nl)
                    {
                    _First_arg = _STD find(_First_arg, _Last, _Meta_nl);
                    if (_First_arg != _Last)
                        ++_First_arg;
                    }

                return (_First_arg);
                }

            case _N_eol:
                return (_STD find(_First_arg, _Last, _Meta_nl));

//          case _N_wbound:
//          case _N_dot:

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

            case _N_class:
                {   // check for string match
                for (; _First_arg != _Last; ++_First_arg)
                    {   // look for starting match
                    bool _Found;
                    typename _RxTraits::_Uelem _Ch = *_First_arg;
                    _Node_class<_Elem, _RxTraits> *_Node =
                        (_Node_class<_Elem, _RxTraits> *)_Nx;
                    _It _Next = _First_arg;
                    ++_Next;

                    if (_Node->_Coll
                        && _Lookup_coll(_First_arg, _Next, _Node->_Coll)
                            != _First_arg)
                        _Found = true;
                    else if (_Node->_Ranges
                        && (_Lookup_range((typename _RxTraits::_Uelem)
                            (_Sflags & regex_constants::collate
                                ? _Traits.translate(_Ch)
                                : _Ch), _Node->_Ranges)))
                        _Found = true;
                    else if (_Ch < _Bmp_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_arg);
                    }
                }
                return (_First_arg);

            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_arg != _Last && _Node != 0;
                    _Node = _Node->_Child)
                    _Last = _Skip(_First_arg, _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_arg);
            }
        if (_Nx)
            _Nx = _Nx->_Next;
        }
    return (_First_arg);
    }

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:

• VS2017/inc/regex