_Parser< _FwdIt, _Elem, _RxTraits > Class Template Reference

Public Types
typedef _RxTraits::char_class_type	char_class_type

Public Member Functions
	_Parser (const _RxTraits &_Tr, _FwdIt _Pfirst, _FwdIt _Plast, regex_constants::syntax_option_type _Fx)
_Root_node *	_Compile ()
unsigned int	_Mark_count () const

Private Member Functions
void	_Error (regex_constants::error_type)
bool	_Is_esc () const
void	_Trans ()
void	_Next ()
void	_Expect (_Meta_type, regex_constants::error_type)
int	_Do_digits (int _Base, int _Count)
bool	_DecimalDigits ()
void	_HexDigits (int)
bool	_OctalDigits ()
void	_Do_ex_class (_Meta_type)
bool	_CharacterClassEscape (bool)
_Prs_ret	_ClassEscape (bool)
_Prs_ret	_ClassAtom ()
void	_ClassRanges ()
void	_CharacterClass ()
bool	_IdentityEscape ()
bool	_Do_ffn (_Elem)
bool	_Do_ffnx (_Elem)
bool	_CharacterEscape ()
void	_AtomEscape ()
void	_Do_capture_group ()
void	_Do_noncapture_group ()
void	_Do_assert_group (bool)
bool	_Wrapped_disjunction ()
void	_Quantifier ()
bool	_Alternative ()
void	_Disjunction ()

Private Attributes
_FwdIt	_Pat
_FwdIt	_Begin
_FwdIt	_End
int	_Grp_idx
int	_Disj_count
vector< bool >	_Finished_grps
_Builder< _FwdIt, _Elem, _RxTraits >	_Nfa
const _RxTraits &	_Traits
regex_constants::syntax_option_type	_Flags
int	_Val
_Elem	_Char
_Meta_type	_Mchar
unsigned int	_L_flags

Member Typedef Documentation

template<class _FwdIt , class _Elem , class _RxTraits >

typedef _RxTraits::char_class_type _Parser< _FwdIt, _Elem, _RxTraits >::char_class_type

Constructor & Destructor Documentation

template<class _FwdIt , class _Elem , class _RxTraits >

_Parser< _FwdIt, _Elem, _RxTraits >::_Parser ( const _RxTraits &  _Tr, _FwdIt  _Pfirst, _FwdIt  _Plast, regex_constants::syntax_option_type  _Fx  )

inline

    : _Pat(_Pfirst), _Begin(_Pfirst), _End(_Plast),
        _Grp_idx(0), _Disj_count(0), _Finished_grps(0),
        _Nfa(_Tr, _Fx), _Traits(_Tr), _Flags(_Fx)
    {   // construct
    using namespace regex_constants;
    _L_flags = (_Flags & _Gmask) == ECMAScript
        || (_Flags & _Gmask) == 0 ? _ECMA_flags
        : (_Flags & _Gmask) == basic ? _Basic_flags
        : (_Flags & _Gmask) == extended ? _Extended_flags
        : (_Flags & _Gmask) == awk ? _Awk_flags
        : (_Flags & _Gmask) == grep ? _Grep_flags
        : (_Flags & _Gmask) == egrep ? _Egrep_flags
        : 0;
    if (_L_flags & _L_mtch_long)
        _Nfa._Setlong();
    _Trans();
    }

Member Function Documentation

template<class _FwdIt , class _Elem , class _RxTraits >

bool _Parser< _FwdIt, _Elem, _RxTraits >::_Alternative ( )

inlineprivate

    {   // check for valid alternative
    bool _Found = false;
    for (; ; )
        {   // concatenate valid elements
        bool _Quant = true;
        if (_Mchar == _Meta_eos || _Mchar == _Meta_bar
            || (_Mchar == _Meta_rpar && _Disj_count != 0))
            return (_Found);
        else if (_Mchar == _Meta_rpar && !(_L_flags & _L_paren_bal))
            _Error(regex_constants::error_paren);
        else if (_Mchar == _Meta_dot)
            {   // add dot node
            _Nfa._Add_dot();
            _Next();
            }
        else if (_Mchar == _Meta_esc)
            {   // check for valid escape sequence
            _Next();
            if ((_L_flags & _L_asrt_wrd) && _Char == _Esc_word)
                {   // add word assert
                _Nfa._Add_wbound();
                _Next();
                _Quant = false;
                }
            else if ((_L_flags & _L_asrt_wrd) && _Char == _Esc_not_word)
                {   // add not-word assert
                _Nfa._Add_wbound();
                _Nfa._Negate();
                _Next();
                _Quant = false;
                }
            else
                _AtomEscape();
            }
        else if (_Mchar == _Meta_lsq)
            {   // add bracket expression
            _Next();
            _CharacterClass();
            _Expect(_Meta_rsq, regex_constants::error_brack);
            }
        else if (_Mchar == _Meta_lpar)
            {   // check for valid group
            _Next();
            _Quant = _Wrapped_disjunction();
            _Expect(_Meta_rpar, regex_constants::error_paren);
            }
        else if (_Mchar == _Meta_caret)
            {   // add bol node
            _Nfa._Add_bol();
            _Next();
            _Quant = false;
            }
        else if (_Mchar == _Meta_dlr)
            {   // add eol node
            _Nfa._Add_eol();
            _Next();
            _Quant = false;
            }
        else if (_Mchar == _Meta_star
            || _Mchar == _Meta_plus
            || _Mchar == _Meta_query
            || _Mchar == _Meta_lbr)
            _Error(regex_constants::error_badrepeat);
        else if (_Mchar == _Meta_rbr && !(_L_flags & _L_paren_bal))
            _Error(regex_constants::error_brace);
        else if (_Mchar == _Meta_rsq && !(_L_flags & _L_paren_bal))
            _Error(regex_constants::error_brack);
        else
            {   // add character
            _Nfa._Add_char(_Char);
            _Next();
            }
        if (_Quant)
            _Quantifier();
        _Found = true;
        }
    }

template<class _FwdIt , class _Elem , class _RxTraits >

void _Parser< _FwdIt, _Elem, _RxTraits >::_AtomEscape ( )

inlineprivate

    {   // check for valid atom escape
    if ((_L_flags & _L_bckr) && _DecimalDigits())
        {   // check for valid back reference
        if (_Val == 0)
            {   // handle \0
            if (!(_L_flags & _L_bzr_chr))
                _Error(regex_constants::error_escape);
            else
                _Nfa._Add_char((_Elem)_Val);
            }
        else if (((_L_flags & _L_lim_bckr) && _BRE_MAX_GRP < _Val)
            || _Grp_idx < _Val || !_Finished_grps[_Val])
            _Error(regex_constants::error_backref);
        else
            _Nfa._Add_backreference(_Val);
        }
    else if (_CharacterEscape())
        _Nfa._Add_char((_Elem)_Val);
    else if (!(_L_flags & _L_esc_wsd) || !_CharacterClassEscape(true))
        _Error(regex_constants::error_escape);
    }

template<class _FwdIt , class _Elem , class _RxTraits >

void _Parser< _FwdIt, _Elem, _RxTraits >::_CharacterClass ( )

inlineprivate

    {   // add bracket expression
    _Nfa._Add_class();
    if (_Mchar == _Meta_caret)
        {   // negate bracket expression
        _Nfa._Negate();
        _Next();
        }
    if ((_L_flags & _L_brk_rstr) && _Mchar == _Meta_rsq)
        {   // insert initial ] when not special
        _Nfa._Add_char_to_class(_Meta_rsq);
        _Next();
        }
    _ClassRanges();
    }

template<class _FwdIt , class _Elem , class _RxTraits >

bool _Parser< _FwdIt, _Elem, _RxTraits >::_CharacterClassEscape ( bool  _Addit )

inlineprivate

    {   // check for character class escape
    typename _RxTraits::char_class_type _Cls;
    _FwdIt _Ch0 = _Pat;
    if (_Ch0 == _End
        || (_Cls = _Traits.lookup_classname(_Pat, ++_Ch0,
            (_Flags & regex_constants::icase) != 0)) == 0)
        return (false);

    if (_Addit)
        _Nfa._Add_class();
    _Nfa._Add_named_class(_Cls);
    if (_Traits.isctype(_Char, _RxTraits::_Ch_upper))
        _Nfa._Negate();
    _Next();
    return (true);
    }

template<class _FwdIt , class _Elem , class _RxTraits >

bool _Parser< _FwdIt, _Elem, _RxTraits >::_CharacterEscape ( )

inlineprivate

    {   // check for valid character escape
    if ((_L_flags & _L_esc_ffn && _Do_ffn(_Char))
        || (_L_flags & _L_esc_ffnx && _Do_ffnx(_Char)))
        _Next();
    else if (_Char == _Esc_ctrl && (_L_flags & _L_esc_ctrl))
        {   // handle control escape sequence
        _Next();
        if (!_Traits.isctype(_Char, _RxTraits::_Ch_alpha))
            _Error(regex_constants::error_escape);
        _Val = (char)(_Char % 32);
        _Next();
        }
    else if (_Char == _Esc_hex && (_L_flags & _L_esc_hex))
        {   // handle hexadecimal escape sequence
        _Next();
        _HexDigits(2);
        }
    else if (_Char == _Esc_uni && (_L_flags & _L_esc_uni))
        {   // handle unicode escape sequence
        _Next();
        _HexDigits(4);
        }
    else if ((_L_flags & _L_esc_oct) && _OctalDigits())
        {   // handle octal escape sequence
        if (_Val == 0)
            _Error(regex_constants::error_escape);
        }
    else
        return (_IdentityEscape());

    typedef typename make_unsigned<_Elem>::type _Uelem;
    if ((numeric_limits<_Uelem>::max)() < (unsigned int)_Val)
        _Error(regex_constants::error_escape);
    _Val = (_Elem)_Val;
    return (true);
    }

template<class _FwdIt , class _Elem , class _RxTraits >

_Prs_ret _Parser< _FwdIt, _Elem, _RxTraits >::_ClassAtom ( )

inlineprivate

    {   // check for class atom
    if (_Mchar == _Meta_esc)
        {   // check for valid escape sequence
        _Next();
        if (_L_flags & _L_grp_esc)
            return (_ClassEscape(false));
        else if ((_L_flags & _L_esc_ffn && _Do_ffn(_Char))
            || (_L_flags & _L_esc_ffnx && _Do_ffnx(_Char)))
            {   // advance to next character
            _Next();
            return (_Prs_chr);
            }
        _Val = _Meta_esc;
        return (_Prs_chr);
        }
    else if (_Mchar == _Meta_lsq)
        {   // check for valid delimited expression
        _Next();
        if (_Mchar == _Meta_colon
            || _Mchar == _Meta_equal
            || _Mchar == _Meta_dot)
            {   // handle delimited expression
            _Meta_type _St = _Mchar;
            _Next();
            _Do_ex_class(_St);
            return (_Prs_set);
            }
        else
            {   // handle ordinary [
            _Val = _Meta_lsq;
            return (_Prs_chr);
            }
        }
    else if (_Mchar == _Meta_rsq || _Mchar == _Meta_eos)
        return (_Prs_none);
    else
        {   // handle ordinary character
        _Val = _Char;
        _Next();
        return (_Prs_chr);
        }
    }

template<class _FwdIt , class _Elem , class _RxTraits >

_Prs_ret _Parser< _FwdIt, _Elem, _RxTraits >::_ClassEscape ( bool  _Addit )

inlineprivate

    {   // check for class escape
    if ((_L_flags & _L_esc_bsl)
        && _Char == _Esc_bsl)
        {   // handle escape backslash if allowed
        _Val = _Esc_bsl;
        _Next();
        return (_Prs_chr);
        }
    else if ((_L_flags & _L_esc_wsd) && _CharacterClassEscape(_Addit))
        return (_Prs_set);
    else if (_DecimalDigits())
        {   // check for invalid value
        if (_Val != 0)
            _Error(regex_constants::error_escape);
        return (_Prs_chr);
        }
    return (_CharacterEscape() ? _Prs_chr : _Prs_none);
    }

template<class _FwdIt , class _Elem , class _RxTraits >

void _Parser< _FwdIt, _Elem, _RxTraits >::_ClassRanges ( )

inlineprivate

    {   // check for valid class ranges
    _Prs_ret _Ret;

    for (; ; )
        {   // process characters through end of bracket expression
        if ((_Ret = _ClassAtom()) == _Prs_none)
            return;
        else if (_Ret == _Prs_set)
            ;
        else if (_Val == 0 && !(_L_flags & _L_bzr_chr))
            _Error(regex_constants::error_escape);
        else if (_Mchar == _Meta_dash)
            {   // check for valid range
            _Next();
            _Elem _Chr1 = (_Elem)_Val;
            if ((_Ret = _ClassAtom()) == _Prs_none)
                {   // treat - as ordinary character
                _Nfa._Add_char_to_class((_Elem)_Val);
                _Nfa._Add_char_to_class(_Meta_dash);
                return;
                }
            else if (_Ret == _Prs_set)
                _Error(regex_constants::error_range);   // set follows dash
            else if (_Flags & regex_constants::collate)
                {   // translate ends of range
                _Val = _Traits.translate((_Elem)_Val);
                _Chr1 = _Traits.translate(_Chr1);
                }
            if (_Val < _Chr1)
                _Error(regex_constants::error_range);
            _Nfa._Add_range(_Chr1, (_Elem)_Val);
            }
        else
            _Nfa._Add_char_to_class((_Elem)_Val);
        }
    }

template<class _FwdIt , class _Elem , class _RxTraits >

_Root_node * _Parser< _FwdIt, _Elem, _RxTraits >::_Compile ( )

inline

    {   // compile regular expression
    _Root_node *_Res = 0;
    _TRY_BEGIN
    _Node_base *_Pos1 = _Nfa._Begin_capture_group(0);
    _Disjunction();
    if (_Pat != _End)
        _Error(regex_constants::error_syntax);
    _Nfa._End_group(_Pos1);
    _Res = _Nfa._End_pattern();
    _Res->_Fl = _Flags;
    _Res->_Marks = _Mark_count();
    _CATCH_ALL
    _Nfa._Discard_pattern();
    _RERAISE;
    _CATCH_END
    return (_Res);
    }

template<class _FwdIt , class _Elem , class _RxTraits >

bool _Parser< _FwdIt, _Elem, _RxTraits >::_DecimalDigits ( )

inlineprivate

    {   // check for decimal value
    return (_Do_digits(10, INT_MAX) != INT_MAX);
    }

template<class _FwdIt , class _Elem , class _RxTraits >

void _Parser< _FwdIt, _Elem, _RxTraits >::_Disjunction ( )

inlineprivate

    {   // check for valid disjunction
    _Node_base *_Pos1 = _Nfa._Getmark();
    if (_Alternative())
        ;
    else if (_Mchar != _Meta_bar)
        return; // zero-length alternative not followed by '|'
    else
        {   // zero-length leading alternative
        _Node_base *_Pos3 = _Nfa._Begin_group();
        _Nfa._End_group(_Pos3);
        }

    _Node_base *_Pos2 = _Nfa._Begin_if(_Pos1);
    while (_Mchar == _Meta_bar)
        {   // append terms as long as we keep finding | characters
        _Next();
        if (!_Alternative())
            {   // zero-length trailing alternative
            _Node_base *_Pos3 = _Nfa._Begin_group();
            _Nfa._End_group(_Pos3);
            }
        _Nfa._Else_if(_Pos1, _Pos2);
        }
    }

template<class _FwdIt , class _Elem , class _RxTraits >

void _Parser< _FwdIt, _Elem, _RxTraits >::_Do_assert_group ( bool  _Neg )

inlineprivate

    {   // add assert group
    _Node_base *_Pos1 = _Nfa._Begin_assert_group(_Neg);
    _Disjunction();
    _Nfa._End_assert_group(_Pos1);
    }

template<class _FwdIt , class _Elem , class _RxTraits >

void _Parser< _FwdIt, _Elem, _RxTraits >::_Do_capture_group ( )

inlineprivate

    {   // add capture group
//  if (_MAX_GRP <= ++_Grp_idx)
//      _Error(regex_constants::error_complexity);
    _Node_base *_Pos1 = _Nfa._Begin_capture_group(++_Grp_idx);
    _Disjunction();
    _Nfa._End_group(_Pos1);
    _Finished_grps.resize(_Grp_idx + 1);
    _Finished_grps[((_Node_capture *)_Pos1)->_Idx] = true;
    }

template<class _FwdIt , class _Elem , class _RxTraits >

int _Parser< _FwdIt, _Elem, _RxTraits >::_Do_digits ( int  _Base, int  _Count  )

inlineprivate

    {   // translate digits to numeric value
    int _Chv;
    _Val = 0;
    while (_Count != 0 && (_Chv = _Traits.value(_Char, _Base)) != -1)
        {   // append next digit
        --_Count;
        _Val *= _Base;
        _Val += _Chv;
        _Next();
        }
    return (_Count);
    }

template<class _FwdIt , class _Elem , class _RxTraits >

void _Parser< _FwdIt, _Elem, _RxTraits >::_Do_ex_class ( _Meta_type  _End )

inlineprivate

    {   // handle delimited expressions within bracket expression
    regex_constants::error_type _Errtype =
        (_End == _Meta_colon ? regex_constants::error_ctype
            : _End == _Meta_equal ? regex_constants::error_collate
            : _End == _Meta_dot ? regex_constants::error_collate
            : regex_constants::error_syntax);
    _FwdIt _Beg = _Pat;
    _REGEX_DIFFT(_FwdIt) _Diff = 0;

    while (_Mchar != _Meta_colon && _Mchar != _Meta_equal
        && _Mchar != _Meta_dot && _Mchar != _Meta_eos)
        {   // advance to end delimiter
        _Next();
        ++_Diff;
        }
    if (_Mchar != _End)
        _Error(_Errtype);
    else if (_End == _Meta_colon)
        {   // handle named character class
        typename _RxTraits::char_class_type _Cls =
            _Traits.lookup_classname(_Beg, _Pat,
                (_Flags & regex_constants::icase) != 0);
        if (!_Cls)
            _Error(regex_constants::error_ctype);
        _Nfa._Add_named_class(_Cls);
        }
    else if (_End == _Meta_equal)
        {   // process =
        if (_Beg == _Pat)
            _Error(regex_constants::error_collate);
        else
            _Nfa._Add_equiv(_Beg, _Pat, _Diff);
        }
    else if (_End == _Meta_dot)
        {   // process .
        if (_Beg == _Pat)
            _Error(regex_constants::error_collate);
        else
            _Nfa._Add_coll(_Beg, _Pat, _Diff);
        }
    _Next();
    _Expect(_Meta_rsq, _Errtype);
    }

template<class _FwdIt , class _Elem , class _RxTraits >

bool _Parser< _FwdIt, _Elem, _RxTraits >::_Do_ffn ( _Elem  _Ch )

inlineprivate

    {   // check for limited file format escape character
    if (_Ch == _Esc_ctrl_b)
        _Val = '\b';
    else if (_Ch == _Esc_ctrl_f)
        _Val = '\f';
    else if (_Ch == _Esc_ctrl_n)
        _Val = '\n';
    else if (_Ch == _Esc_ctrl_r)
        _Val = '\r';
    else if (_Ch == _Esc_ctrl_t)
        _Val = '\t';
    else if (_Ch == _Esc_ctrl_v)
        _Val = '\v';
    else
        return (false);
    return (true);
    }

template<class _FwdIt , class _Elem , class _RxTraits >

bool _Parser< _FwdIt, _Elem, _RxTraits >::_Do_ffnx ( _Elem  _Ch )

inlineprivate

    {   // check for the remaining file format escape character
    if (_Ch == _Esc_ctrl_a)
        _Val = '\a';
    else
        return (false);
    return (true);
    }

template<class _FwdIt , class _Elem , class _RxTraits >

void _Parser< _FwdIt, _Elem, _RxTraits >::_Do_noncapture_group ( )

inlineprivate

    {   // add non-capture group
    _Node_base *_Pos1 = _Nfa._Begin_group();
    _Disjunction();
    _Nfa._End_group(_Pos1);
    }

template<class _FwdIt , class _Elem , class _RxTraits >

void _Parser< _FwdIt, _Elem, _RxTraits >::_Error ( regex_constants::error_type  _Code )

inlineprivate

    {   // handle error
    _Xregex_error(_Code);
    }

template<class _FwdIt , class _Elem , class _RxTraits >

void _Parser< _FwdIt, _Elem, _RxTraits >::_Expect ( _Meta_type  _St, regex_constants::error_type  _Code  )

inlineprivate

    {   // check whether current meta-character is _St
    if (_Mchar != _St)
        _Error(_Code);
    _Next();
    }

template<class _FwdIt , class _Elem , class _RxTraits >

void _Parser< _FwdIt, _Elem, _RxTraits >::_HexDigits ( int  _Count )

inlineprivate

    {   // check for _Count hex digits
    if (_Do_digits(16, _Count) != 0)
        _Error(regex_constants::error_escape);
    }

template<class _FwdIt , class _Elem , class _RxTraits >

bool _Parser< _FwdIt, _Elem, _RxTraits >::_IdentityEscape ( )

inlineprivate

    {   // check for valid identity escape
    if ((_L_flags & _L_ident_ECMA) &&
        // ECMAScript identity escape characters
        !_Traits.isctype(_Char, _RxTraits::_Ch_alnum)
            && _Char != '_')
        ;
    else if (!(_L_flags & _L_ident_ECMA) &&
        // BRE, ERE, awk identity escape characters
        (_Char == _Meta_dot
        || _Char == _Meta_lsq
        || _Char == _Meta_esc
        || _Char == _Meta_star
        || _Char == _Meta_bar
        || _Char == _Meta_caret
        || _Char == _Meta_dlr))
        ;
    else if ((_L_flags & _L_ident_ERE) &&
        // additional ERE identity escape characters
        (_Char == _Meta_lpar
        || _Char == _Meta_rpar
        || _Char == _Meta_plus
        || _Char == _Meta_query
        || _Char == _Meta_lbr
        || _Char == _Meta_rbr))
        ;
    else if ((_L_flags & _L_ident_awk) &&
        // additional awk identity escape characters
        (_Char == '"' || _Char == '/'))
        ;
    else
        return (false);
    _Val = _Char;
    _Next();
    return (true);
    }

template<class _FwdIt , class _Elem , class _RxTraits >

bool _Parser< _FwdIt, _Elem, _RxTraits >::_Is_esc ( ) const

inlineprivate

    {   // assumes _Pat != _End
    _FwdIt _Ch0 = _Pat;
    return (++_Ch0 != _End
        && ((!(_L_flags & _L_nex_grp)
            && (*_Ch0 == _Meta_lpar || *_Ch0 == _Meta_rpar))
        || (!(_L_flags & _L_nex_rep)
            && (*_Ch0 == _Meta_lbr || *_Ch0 == _Meta_rbr))));
    }

template<class _FwdIt , class _Elem , class _RxTraits >

unsigned int _Parser< _FwdIt, _Elem, _RxTraits >::_Mark_count ( ) const

inline

        {   // return number of capture groups
        return (_Grp_idx + 1);
        }

template<class _FwdIt , class _Elem , class _RxTraits >

void _Parser< _FwdIt, _Elem, _RxTraits >::_Next ( )

inlineprivate

    {   // advance to next input character
    if (_Pat != _End)
        {   // advance
        if (*_Pat == _Meta_esc && _Is_esc())
            ++_Pat;
        ++_Pat;
        }
    _Trans();
    }

template<class _FwdIt , class _Elem , class _RxTraits >

bool _Parser< _FwdIt, _Elem, _RxTraits >::_OctalDigits ( )

inlineprivate

    {   // check for up to 3 octal digits
    return (_Do_digits(8, 3) != 3);
    }

template<class _FwdIt , class _Elem , class _RxTraits >

void _Parser< _FwdIt, _Elem, _RxTraits >::_Quantifier ( )

inlineprivate

    {   // check for quantifier following atom
    int _Min = 0;
    int _Max = -1;
    if (_Mchar == _Meta_star)
        ;
    else if (_Mchar == _Meta_plus)
        _Min = 1;
    else if (_Mchar == _Meta_query)
        _Max = 1;
    else if (_Mchar == _Meta_lbr)
        {   // check for valid bracketed value
        _Next();
        if (!_DecimalDigits())
            _Error(regex_constants::error_badbrace);
        _Min = _Val;
        if (_Mchar != _Meta_comma)
            _Max = _Min;
        else
            {   // check for decimal constant following comma
            _Next();
            if (_Mchar == _Meta_rbr)
                ;
            else if (!_DecimalDigits())
                _Error(regex_constants::error_badbrace);
            else
                _Max = _Val;
            }
        if (_Mchar != _Meta_rbr || (_Max != -1 && _Max < _Min))
            _Error(regex_constants::error_badbrace);
        }
    else
        return;
    _Nfa._Mark_final();
    _Next();
    if ((_L_flags & _L_ngr_rep) && _Mchar == _Meta_query)
        {   // add non-greedy repeat node
        _Next();
        _Nfa._Add_rep(_Min, _Max, false);
        }
    else
        _Nfa._Add_rep(_Min, _Max, true);
    }

template<class _FwdIt , class _Elem , class _RxTraits >

void _Parser< _FwdIt, _Elem, _RxTraits >::_Trans ( )

inlineprivate

    {   // map character to meta-character
    if (_Pat == _End)
        _Mchar = _Meta_eos, _Char = (_Elem)_Meta_eos;
    else
        {   // map current character
        _Char = *_Pat;
        _Mchar = _CSTD strchr(_Meta_map, _Char) != 0
            ? (_Meta_type)_Char : _Meta_chr;
        }
    switch (_Char)
        {   // handle special cases
        case _Meta_esc:
            if (_Is_esc())
                {   // replace escape sequence
                _FwdIt _Ch0 = _Pat;
                _Mchar = _Meta_type(_Char = *++_Ch0);
                }
            break;

        case _Meta_nl:
            if ((_L_flags & _L_alt_nl) && _Disj_count == 0)
                _Mchar = _Meta_bar;
            break;

        case _Meta_lpar:
        case _Meta_rpar:
            if (!(_L_flags & _L_nex_grp))
                _Mchar = _Meta_chr;
            break;

        case _Meta_lbr:
        case _Meta_rbr:
            if (!(_L_flags & _L_nex_rep))
                _Mchar = _Meta_chr;
            break;

        case _Meta_star:
            if ((_L_flags & _L_star_beg)
                && _Nfa._Beg_expr())
                _Mchar = _Meta_chr;
            break;

        case _Meta_caret:
            if ((_L_flags & _L_anch_rstr)
                && !_Nfa._Beg_expr())
            _Mchar = _Meta_chr;
            break;

        case _Meta_dlr:
            {   // check if $ is special
            _FwdIt _Ch0 = _Pat;
            if ((_L_flags & _L_anch_rstr)
                && ++_Ch0 != _End && *_Ch0 != _Meta_nl)
                _Mchar = _Meta_chr;
            break;
            }

        case _Meta_plus:
        case _Meta_query:
            if (!(_L_flags & _L_ext_rep))
                _Mchar = _Meta_chr;
            break;

        case _Meta_bar:
            if (!(_L_flags & _L_alt_pipe))
                _Mchar = _Meta_chr;
            break;
        }
    }

template<class _FwdIt , class _Elem , class _RxTraits >

bool _Parser< _FwdIt, _Elem, _RxTraits >::_Wrapped_disjunction ( )

inlineprivate

    {   // add disjunction inside group
    ++_Disj_count;
    if (!(_L_flags & _L_empty_grp) && _Mchar == _Meta_rpar)
        _Error(regex_constants::error_paren);
    else if ((_L_flags & _L_nc_grp) && _Mchar == _Meta_query)
        {   // check for valid ECMAScript (?x ... ) group
        _Next();
        _Meta_type _Ch =_Mchar;
        _Next();
        if (_Ch == _Meta_colon)
            _Do_noncapture_group();
        else if (_Ch == _Meta_exc)
            {   // process assert group, negating
            _Do_assert_group(true);
            --_Disj_count;
            return (false);
            }
        else if (_Ch == _Meta_equal)
            {   // process assert group
            _Do_assert_group(false);
            --_Disj_count;
            return (false);
            }
        else
            _Error(regex_constants::error_syntax);
        }
    else if (_Flags & regex_constants::nosubs)
        _Do_noncapture_group();
    else
        _Do_capture_group();
        --_Disj_count;
    return (true);
    }

Member Data Documentation

template<class _FwdIt , class _Elem , class _RxTraits >

_FwdIt _Parser< _FwdIt, _Elem, _RxTraits >::_Begin

private

template<class _FwdIt , class _Elem , class _RxTraits >

_Elem _Parser< _FwdIt, _Elem, _RxTraits >::_Char

private

template<class _FwdIt , class _Elem , class _RxTraits >

int _Parser< _FwdIt, _Elem, _RxTraits >::_Disj_count

private

template<class _FwdIt , class _Elem , class _RxTraits >

_FwdIt _Parser< _FwdIt, _Elem, _RxTraits >::_End

private

template<class _FwdIt , class _Elem , class _RxTraits >

vector<bool> _Parser< _FwdIt, _Elem, _RxTraits >::_Finished_grps

private

template<class _FwdIt , class _Elem , class _RxTraits >

regex_constants::syntax_option_type _Parser< _FwdIt, _Elem, _RxTraits >::_Flags

private

template<class _FwdIt , class _Elem , class _RxTraits >

int _Parser< _FwdIt, _Elem, _RxTraits >::_Grp_idx

private

template<class _FwdIt , class _Elem , class _RxTraits >

unsigned int _Parser< _FwdIt, _Elem, _RxTraits >::_L_flags

private

template<class _FwdIt , class _Elem , class _RxTraits >

_Meta_type _Parser< _FwdIt, _Elem, _RxTraits >::_Mchar

private

template<class _FwdIt , class _Elem , class _RxTraits >

_Builder<_FwdIt, _Elem, _RxTraits> _Parser< _FwdIt, _Elem, _RxTraits >::_Nfa

private

template<class _FwdIt , class _Elem , class _RxTraits >

_FwdIt _Parser< _FwdIt, _Elem, _RxTraits >::_Pat

private

template<class _FwdIt , class _Elem , class _RxTraits >

const _RxTraits& _Parser< _FwdIt, _Elem, _RxTraits >::_Traits

private

template<class _FwdIt , class _Elem , class _RxTraits >

int _Parser< _FwdIt, _Elem, _RxTraits >::_Val

private

---

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

• VS2013/inc/regex