_Builder< _FwdIt, _Elem, _RxTraits > Class Template Reference

Public Types
typedef iterator_traits< _FwdIt >::difference_type	_Difft

Public Member Functions
	_Builder (const _RxTraits &_Tr, regex_constants::syntax_option_type)
bool	_Beg_expr () const
void	_Setlong ()
void	_Discard_pattern ()
_Node_base *	_Getmark () const
void	_Add_nop ()
void	_Add_bol ()
void	_Add_eol ()
void	_Add_wbound ()
void	_Add_dot ()
void	_Add_char (_Elem _Ch)
void	_Add_class ()
void	_Add_char_to_class (_Elem _Ch)
void	_Add_range (_Elem _E0, _Elem _E1)
void	_Add_named_class (_Regex_traits_base::char_class_type, bool=false)
void	_Add_equiv (_FwdIt, _FwdIt, _Difft)
void	_Add_coll (_FwdIt, _FwdIt, _Difft)
_Node_base *	_Begin_group ()
void	_End_group (_Node_base *_Back)
_Node_base *	_Begin_assert_group (bool)
void	_End_assert_group (_Node_base *)
_Node_base *	_Begin_capture_group (unsigned int _Idx)
void	_Add_backreference (unsigned int _Idx)
_Node_base *	_Begin_if (_Node_base *_Start)
void	_Else_if (_Node_base *, _Node_base *)
void	_Add_rep (int _Min, int _Max, bool _Greedy)
void	_Negate ()
void	_Mark_final ()
_Root_node *	_End_pattern ()

Private Member Functions
_Node_base *	_Link_node (_Node_base *)
_Node_base *	_New_node (_Node_type _Kind)
void	_Add_str_node ()
bool	_Beg_expr (_Node_base *) const
void	_Add_char_to_bitmap (_Elem _Ch)
void	_Add_char_to_array (_Elem _Ch)
void	_Add_elts (_Node_class< _Elem, _RxTraits > *, _Regex_traits_base::char_class_type, bool)
void	_Char_to_elts (_FwdIt, _FwdIt, _Difft, _Sequence< _Elem > **)
unsigned int	_Get_bmax () const
unsigned int	_Get_tmax () const
_Builder &	operator= (const _Builder &)

Static Private Member Functions
static void	_Insert_node (_Node_base *, _Node_base *)

Private Attributes
_Root_node *	_Root
_Node_base *	_Current
regex_constants::syntax_option_type	_Flags
const _RxTraits &	_Traits
const int	_Bmax
const int	_Tmax

Member Typedef Documentation

template<class _FwdIt , class _Elem , class _RxTraits >

typedef iterator_traits<_FwdIt>::difference_type _Builder< _FwdIt, _Elem, _RxTraits >::_Difft

Constructor & Destructor Documentation

template<class _FwdIt , class _Elem , class _RxTraits >

_Builder< _FwdIt, _Elem, _RxTraits >::_Builder ( const _RxTraits &  _Tr, regex_constants::syntax_option_type  _Fx  )

inline

    : _Root(new _Root_node),
        _Current(_Root),
        _Flags(_Fx),
        _Traits(_Tr),
        _Bmax(static_cast<int>(_Fx & regex_constants::collate ? 0U : _Bmp_max)),
        _Tmax(static_cast<int>(_Fx & regex_constants::collate ? 0U : _ARRAY_THRESHOLD))
    {   // construct
    }

Member Function Documentation

template<class _FwdIt , class _Elem , class _RxTraits >

void _Builder< _FwdIt, _Elem, _RxTraits >::_Add_backreference ( unsigned int  _Idx )

inline

    {   // add back reference node
    _Link_node(new _Node_back(_Idx));
    }

template<class _FwdIt , class _Elem , class _RxTraits >

void _Builder< _FwdIt, _Elem, _RxTraits >::_Add_bol ( )

inline

    {   // add bol node
    _New_node(_N_bol);
    }

template<class _FwdIt , class _Elem , class _RxTraits >

void _Builder< _FwdIt, _Elem, _RxTraits >::_Add_char ( _Elem  _Ch )

inline

    {   // append character
    if (_Current->_Kind != _N_str || _Current->_Flags & _Fl_final)
        _Add_str_node();
    if (_Flags & regex_constants::icase)
        _Ch = _Traits.translate_nocase(_Ch);
    else if (_Flags & regex_constants::collate)
        _Ch = _Traits.translate(_Ch);
    _Node_str<_Elem> *_Node = (_Node_str<_Elem> *)_Current;
    _Node->_Data._Insert(_Ch);
    }

template<class _FwdIt , class _Elem , class _RxTraits >

void _Builder< _FwdIt, _Elem, _RxTraits >::_Add_char_to_array ( _Elem  _Ch )

inlineprivate

    {   // append character to character array
    if (_Flags & regex_constants::icase)
        _Ch = _Traits.translate_nocase(_Ch);
    _Node_class<_Elem, _RxTraits> *_Node =
        (_Node_class<_Elem, _RxTraits> *)_Current;
    if (!_Node->_Large)
        _Node->_Large = new _Buf<_Elem>;
    _Node->_Large->_Insert(_Ch);
    }

template<class _FwdIt , class _Elem , class _RxTraits >

void _Builder< _FwdIt, _Elem, _RxTraits >::_Add_char_to_bitmap ( _Elem  _Ch )

inlineprivate

    {   // add character to accelerator table
    if (_Flags & regex_constants::icase)
        _Ch = _Traits.translate_nocase(_Ch);
    _Node_class<_Elem, _RxTraits> *_Node =
        (_Node_class<_Elem, _RxTraits> *)_Current;

    if (!_Node->_Small)
        _Node->_Small = new _Bitmap;
    _Node->_Small->_Mark(static_cast<typename _RxTraits::_Uelem>(_Ch));
    }

template<class _FwdIt , class _Elem , class _RxTraits >

void _Builder< _FwdIt, _Elem, _RxTraits >::_Add_char_to_class ( _Elem  _Ch )

inline

    {   // add character to bracket expression
    if (static_cast<typename _RxTraits::_Uelem>(_Ch) < _Bmp_max)
        _Add_char_to_bitmap(_Ch);
    else
        _Add_char_to_array(_Ch);
    }

template<class _FwdIt , class _Elem , class _RxTraits >

void _Builder< _FwdIt, _Elem, _RxTraits >::_Add_class ( )

inline

    {   // add bracket expression node
    _Link_node(new _Node_class<_Elem, _RxTraits>);
    }

template<class _FwdIt , class _Elem , class _RxTraits >

void _Builder< _FwdIt, _Elem, _RxTraits >::_Add_coll ( _FwdIt  _First, _FwdIt  _Last, _Difft  _Diff  )

inline

    {   // add collation element to bracket expression
    _Node_class<_Elem, _RxTraits> *_Node =
        (_Node_class<_Elem, _RxTraits> *)_Current;
    _Sequence<_Elem> **_Cur = &_Node->_Coll;
    _Char_to_elts(_First, _Last, _Diff, _Cur);
    }

template<class _FwdIt , class _Elem , class _RxTraits >

void _Builder< _FwdIt, _Elem, _RxTraits >::_Add_dot ( )

inline

    {   // add dot node
    _New_node(_N_dot);
    }

template<class _FwdIt , class _Elem , class _RxTraits >

void _Builder< _FwdIt, _Elem, _RxTraits >::_Add_elts ( _Node_class< _Elem, _RxTraits > *  _Node, _Regex_traits_base::char_class_type  _Cl, bool  _Negate  )

inlineprivate

    {   // add characters in named class to set
    for (unsigned int _Ch = 0; _Ch < _Bmp_max; ++_Ch)
        {   // add elements or their inverse
        bool _Matches = _Traits.isctype(static_cast<_Elem>(_Ch), _Cl);
        if (_Matches != _Negate)
            {   // add contents of named class to accelerator table
            if (!_Node->_Small)
                _Node->_Small = new _Bitmap;
            _Node->_Small->_Mark(_Ch);
            }
        }
    }

template<class _FwdIt , class _Elem , class _RxTraits >

void _Builder< _FwdIt, _Elem, _RxTraits >::_Add_eol ( )

inline

    {   // add eol node
    _New_node(_N_eol);
    }

template<class _FwdIt , class _Elem , class _RxTraits >

void _Builder< _FwdIt, _Elem, _RxTraits >::_Add_equiv ( _FwdIt  _First, _FwdIt  _Last, _Difft  _Diff  )

inline

    {   // add elements of equivalence class to bracket expression
    _Node_class<_Elem, _RxTraits> *_Node =
        (_Node_class<_Elem, _RxTraits> *)_Current;
    typename _RxTraits::string_type _Str =
        _Traits.transform_primary(_First, _Last);
    for (unsigned int _Ch = 0; _Ch < _Bmp_max; ++_Ch)
        {   // add elements
        _Elem _Ex = (_Elem)_Ch;
        if (_Traits.transform_primary(&_Ex, &_Ex + 1) == _Str)
            {   // insert equivalent character into bitmap
            if (!_Node->_Small)
                _Node->_Small = new _Bitmap;
            _Node->_Small->_Mark(_Ch);
            }
        }
    if (_Bmp_max < static_cast<unsigned int>((numeric_limits<_Elem>::max)()))
        {   // map range
        _Sequence<_Elem> **_Cur = &_Node->_Equiv;
        _Char_to_elts(_First, _Last, _Diff, _Cur);
        }
    }

template<class _FwdIt , class _Elem , class _RxTraits >

void _Builder< _FwdIt, _Elem, _RxTraits >::_Add_named_class ( _Regex_traits_base::char_class_type  _Cl, bool  _Negate = false  )

inline

    {   // add contents of named class to bracket expression
    _Node_class<_Elem, _RxTraits> *_Node =
        (_Node_class<_Elem, _RxTraits> *)_Current;
    _Add_elts(_Node, _Cl, _Negate);
    if (_Bmp_max < static_cast<unsigned int>((numeric_limits<_Elem>::max)()))
        _Node->_Classes =
            (_Regex_traits_base::char_class_type)(_Node->_Classes | _Cl);
    }

template<class _FwdIt , class _Elem , class _RxTraits >

void _Builder< _FwdIt, _Elem, _RxTraits >::_Add_nop ( )

inline

    {   // add nop node
    _New_node(_N_nop);
    }

template<class _FwdIt , class _Elem , class _RxTraits >

void _Builder< _FwdIt, _Elem, _RxTraits >::_Add_range ( _Elem  _E0, _Elem  _E1  )

inline

    {   // add character range to set
    unsigned int _E0 = (typename _RxTraits::_Uelem)_E0x;
    unsigned int _E1 = (typename _RxTraits::_Uelem)_E1x;
    if (_Flags & regex_constants::icase)
        {   // change to lowercase range
        _E0 = _Traits.translate_nocase((_Elem)_E0);
        _E1 = _Traits.translate_nocase((_Elem)_E1);
        }
    _Node_class<_Elem, _RxTraits> *_Node =
        (_Node_class<_Elem, _RxTraits> *)_Current;
    for (; _E0 <= _E1 && _E1 < _Get_bmax(); ++_E0)
        {   // set a bit
        if (!_Node->_Small)
            _Node->_Small = new _Bitmap;
        _Node->_Small->_Mark(_E0);
        }
    if (_E1 < _E0)
        ;
    else if (_E1 - _E0 < _Get_tmax())
        for (; _E0 <= _E1; ++_E0)
            _Add_char_to_array((_Elem)_E0);
    else
        {   // store remaining range as pair
        if (!_Node->_Ranges)
            _Node->_Ranges = new _Buf<_Elem>;
        _Node->_Ranges->_Insert((_Elem)_E0);
        _Node->_Ranges->_Insert((_Elem)_E1);
        }
    }

template<class _FwdIt , class _Elem , class _RxTraits >

void _Builder< _FwdIt, _Elem, _RxTraits >::_Add_rep ( int  _Min, int  _Max, bool  _Greedy  )

inline

    {   // add repeat node
    if (_Current->_Kind == _N_str
        && ((_Node_str<_Elem> *)_Current)->_Data._Size() != 1)
        {   // move final character to new string node
        _Node_str<_Elem> *_Node = (_Node_str<_Elem> *)_Current;
        _Add_char(_Node->_Data._Del());
        }

    _Node_base *_Pos = _Current;
    if (_Pos->_Kind == _N_end_group
        || _Pos->_Kind == _N_end_capture)
        _Pos = ((_Node_end_group *)_Pos)->_Back;

    if (_Min == 0 && _Max == 1)
        {   // rewrite zero-or-one quantifiers as alternations to make the
            // "simple loop" optimization more likely to engage
        _Node_endif *_End = new _Node_endif;
        _Node_if *_If_expr = new _Node_if(_End);
        _Node_if *_If_empty_str = new _Node_if(_End);
        _Node_base *_Gbegin = new _Node_base(_N_group);
        _Node_end_group *_Gend = new _Node_end_group(_N_end_group, _Fl_none, _Gbegin);

        _If_empty_str->_Next = _Gbegin;
        _Gbegin->_Prev = _If_empty_str;

        _Gbegin->_Next = _Gend;
        _Gend->_Prev = _Gbegin;

        _Gend->_Next = _End;

        _If_expr->_Child = _If_empty_str;

        _Link_node(_End);
        _Insert_node(_Pos, _If_expr);

        if (!_Greedy)
            {
            _Swap_adl(_If_expr->_Next->_Prev, _If_empty_str->_Next->_Prev);
            _Swap_adl(_If_expr->_Next, _If_empty_str->_Next);
            }
        }
    else
        {
        _Node_end_rep *_Node0 = new _Node_end_rep();
        _Node_rep *_Nx =
            new _Node_rep(_Greedy, _Min, _Max, _Node0, _Root->_Loops++);
        _Node0->_Begin_rep = _Nx;
        _Link_node(_Node0);
        _Insert_node(_Pos, _Nx);
        }
    }

template<class _FwdIt , class _Elem , class _RxTraits >

void _Builder< _FwdIt, _Elem, _RxTraits >::_Add_str_node ( )

inlineprivate

    {   // add string node
    _Link_node(new _Node_str<_Elem>);
    }

template<class _FwdIt , class _Elem , class _RxTraits >

void _Builder< _FwdIt, _Elem, _RxTraits >::_Add_wbound ( )

inline

    {   // add wbound node
    _New_node(_N_wbound);
    }

template<class _FwdIt , class _Elem , class _RxTraits >

bool _Builder< _FwdIt, _Elem, _RxTraits >::_Beg_expr ( ) const

inline

    {   // test for beginning of expression or subexpression
    return (_Beg_expr(_Current)
        || (_Current->_Kind == _N_bol && _Beg_expr(_Current->_Prev)));
    }

template<class _FwdIt , class _Elem , class _RxTraits >

bool _Builder< _FwdIt, _Elem, _RxTraits >::_Beg_expr ( _Node_base *  _Nx ) const

inlineprivate

    {   // test for beginning of expression or subexpression
    return (_Nx->_Kind == _N_begin
        || _Nx->_Kind == _N_group
        || _Nx->_Kind == _N_capture);
    }

template<class _FwdIt , class _Elem , class _RxTraits >

_Node_base * _Builder< _FwdIt, _Elem, _RxTraits >::_Begin_assert_group ( bool  _Neg )

inline

    {   // add assert node
    _Node_assert *_Node1 = new _Node_assert(_Neg
        ? _N_neg_assert : _N_assert);

    _Node_base *_Node2;
    _TRY_BEGIN
    _Node2 = new _Node_base(_N_nop);
    _CATCH_ALL
    delete _Node1;
    _RERAISE;
    _CATCH_END

    _Link_node(_Node1);
    _Node1->_Child = _Node2;
    _Node2->_Prev = _Node1;
    _Current = _Node2;
    return (_Node1);
    }

template<class _FwdIt , class _Elem , class _RxTraits >

_Node_base * _Builder< _FwdIt, _Elem, _RxTraits >::_Begin_capture_group ( unsigned int  _Idx )

inline

    {   // add capture group node
    return (_Link_node(new _Node_capture(_Idx)));
    }

template<class _FwdIt , class _Elem , class _RxTraits >

_Node_base * _Builder< _FwdIt, _Elem, _RxTraits >::_Begin_group ( )

inline

    {   // add group node
    return (_New_node(_N_group));
    }

template<class _FwdIt , class _Elem , class _RxTraits >

_Node_base * _Builder< _FwdIt, _Elem, _RxTraits >::_Begin_if ( _Node_base *  _Start )

inline

    {   // add if node
    /* append endif node */
    _Node_base *_Res = new _Node_endif;
    _Link_node(_Res);

    /* insert if_node */
    _Node_if *_Node1 = new _Node_if(_Res);
    _Node_base *_Pos = _Start->_Next;
    _Insert_node(_Pos, _Node1);
    return (_Res);
    }

template<class _FwdIt , class _Elem , class _RxTraits >

void _Builder< _FwdIt, _Elem, _RxTraits >::_Char_to_elts ( _FwdIt  _First, _FwdIt  _Last, _Difft  _Diff, _Sequence< _Elem > **  _Cur  )

inlineprivate

    {   // add collation element to element sequence
    while (*_Cur && (unsigned int)_Diff < (*_Cur)->_Sz)
        _Cur = &(*_Cur)->_Next;
    if (!(*_Cur) || (unsigned int)_Diff != (*_Cur)->_Sz)
        {   // add new sequence holding elements of the same length
        _Sequence<_Elem> *_Node = *_Cur;
        *_Cur = new _Sequence<_Elem>((unsigned int)_Diff);
        (*_Cur)->_Next = _Node;
        }
    (*_Cur)->_Data._Insert(_First, _Last);
    }

template<class _FwdIt , class _Elem , class _RxTraits >

void _Builder< _FwdIt, _Elem, _RxTraits >::_Discard_pattern ( )

inline

    {   // free memory
    _Destroy_node(_Root);
    _Root = 0;
    }

template<class _FwdIt , class _Elem , class _RxTraits >

void _Builder< _FwdIt, _Elem, _RxTraits >::_Else_if ( _Node_base *  _Start, _Node_base *  _End  )

inline

    {   // add else node
    _Node_if *_Parent = (_Node_if *)_Start->_Next;
    _Node_base *_First = _End->_Next;
    _End->_Next = 0;
    _Node_base *_Last = _Current;
    _Current = _End;
    _End->_Next = 0;
    _Last->_Next = _End;
    while (_Parent->_Child)
        _Parent = _Parent->_Child;
    _Parent->_Child = new _Node_if(_End);
    _Parent->_Child->_Next = _First;
    _First->_Prev = _Parent->_Child;
    }

template<class _FwdIt , class _Elem , class _RxTraits >

void _Builder< _FwdIt, _Elem, _RxTraits >::_End_assert_group ( _Node_base *  _Nx )

inline

    {   // add end of assert node
    _End_group(_Nx);
    _Current = _Nx;
    }

template<class _FwdIt , class _Elem , class _RxTraits >

void _Builder< _FwdIt, _Elem, _RxTraits >::_End_group ( _Node_base *  _Back )

inline

    {   // add end of group node
    _Node_type _Elt = _Back->_Kind == _N_group ? _N_end_group
        : _Back->_Kind == _N_assert ? _N_end_assert
        : _Back->_Kind == _N_neg_assert ? _N_end_assert
        : _N_end_capture;
    _Link_node(new _Node_end_group(_Elt, _Fl_none, _Back));
    }

template<class _FwdIt , class _Elem , class _RxTraits >

_Root_node * _Builder< _FwdIt, _Elem, _RxTraits >::_End_pattern ( )

inline

    {   // wrap up
    _New_node(_N_end);
    return (_Root);
    }

template<class _FwdIt , class _Elem , class _RxTraits >

unsigned int _Builder< _FwdIt, _Elem, _RxTraits >::_Get_bmax ( ) const

inlineprivate

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

template<class _FwdIt , class _Elem , class _RxTraits >

unsigned int _Builder< _FwdIt, _Elem, _RxTraits >::_Get_tmax ( ) const

inlineprivate

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

template<class _FwdIt , class _Elem , class _RxTraits >

_Node_base * _Builder< _FwdIt, _Elem, _RxTraits >::_Getmark ( ) const

inline

    {   // return current node
    return (_Current);
    }

template<class _FwdIt , class _Elem , class _RxTraits >

void _Builder< _FwdIt, _Elem, _RxTraits >::_Insert_node ( _Node_base *  _Insert_before, _Node_base *  _To_insert  )

inlinestaticprivate

    {   // insert _To_insert into the graph before the node _Insert_before
    _Insert_before->_Prev->_Next = _To_insert;
    _To_insert->_Prev = _Insert_before->_Prev;
    _Insert_before->_Prev = _To_insert;
    _To_insert->_Next = _Insert_before;
    }

template<class _FwdIt , class _Elem , class _RxTraits >

_Node_base * _Builder< _FwdIt, _Elem, _RxTraits >::_Link_node ( _Node_base *  _Nx )

inlineprivate

    {   // insert _Nx at current location
    _Nx->_Prev = _Current;
    if (_Current->_Next)
        {   // set back pointer
        _Nx->_Next = _Current->_Next;
        _Current->_Next->_Prev = _Nx;
        }
    _Current->_Next = _Nx;
    _Current = _Nx;
    return (_Nx);
    }

template<class _FwdIt , class _Elem , class _RxTraits >

void _Builder< _FwdIt, _Elem, _RxTraits >::_Mark_final ( )

inline

    {   // set flag
    _Current->_Flags |= _Fl_final;
    }

template<class _FwdIt , class _Elem , class _RxTraits >

void _Builder< _FwdIt, _Elem, _RxTraits >::_Negate ( )

inline

    {   // set flag
    _Current->_Flags ^= _Fl_negate;
    }

template<class _FwdIt , class _Elem , class _RxTraits >

_Node_base * _Builder< _FwdIt, _Elem, _RxTraits >::_New_node ( _Node_type  _Kind )

inlineprivate

    {   // allocate and link simple node
    return (_Link_node(new _Node_base(_Kind)));
    }

template<class _FwdIt , class _Elem , class _RxTraits >

void _Builder< _FwdIt, _Elem, _RxTraits >::_Setlong ( )

inline

    {   // set flag
    _Root->_Flags |= _Fl_longest;
    }

template<class _FwdIt , class _Elem , class _RxTraits >

_Builder& _Builder< _FwdIt, _Elem, _RxTraits >::operator= ( const _Builder< _FwdIt, _Elem, _RxTraits > &  )

private

Member Data Documentation

template<class _FwdIt , class _Elem , class _RxTraits >

const int _Builder< _FwdIt, _Elem, _RxTraits >::_Bmax

private

template<class _FwdIt , class _Elem , class _RxTraits >

_Node_base* _Builder< _FwdIt, _Elem, _RxTraits >::_Current

private

template<class _FwdIt , class _Elem , class _RxTraits >

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

private

template<class _FwdIt , class _Elem , class _RxTraits >

_Root_node* _Builder< _FwdIt, _Elem, _RxTraits >::_Root

private

template<class _FwdIt , class _Elem , class _RxTraits >

const int _Builder< _FwdIt, _Elem, _RxTraits >::_Tmax

private

template<class _FwdIt , class _Elem , class _RxTraits >

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

private

---

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

• VS2017/inc/regex