239 lines
7.7 KiB
C++
239 lines
7.7 KiB
C++
// class template regex -*- C++ -*-
|
|
|
|
// Copyright (C) 2013-2015 Free Software Foundation, Inc.
|
|
//
|
|
// This file is part of the GNU ISO C++ Library. This library is free
|
|
// software; you can redistribute it and/or modify it under the
|
|
// terms of the GNU General Public License as published by the
|
|
// Free Software Foundation; either version 3, or (at your option)
|
|
// any later version.
|
|
|
|
// This library is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU General Public License for more details.
|
|
|
|
// Under Section 7 of GPL version 3, you are granted additional
|
|
// permissions described in the GCC Runtime Library Exception, version
|
|
// 3.1, as published by the Free Software Foundation.
|
|
|
|
// You should have received a copy of the GNU General Public License and
|
|
// a copy of the GCC Runtime Library Exception along with this program;
|
|
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
|
|
// <http://www.gnu.org/licenses/>.
|
|
|
|
/**
|
|
* @file bits/regex_automaton.tcc
|
|
* This is an internal header file, included by other library headers.
|
|
* Do not attempt to use it directly. @headername{regex}
|
|
*/
|
|
|
|
namespace std _GLIBCXX_VISIBILITY(default)
|
|
{
|
|
namespace __detail
|
|
{
|
|
_GLIBCXX_BEGIN_NAMESPACE_VERSION
|
|
|
|
#ifdef _GLIBCXX_DEBUG
|
|
inline std::ostream&
|
|
_State_base::_M_print(std::ostream& ostr) const
|
|
{
|
|
switch (_M_opcode)
|
|
{
|
|
case _S_opcode_alternative:
|
|
case _S_opcode_repeat:
|
|
ostr << "alt next=" << _M_next << " alt=" << _M_alt;
|
|
break;
|
|
case _S_opcode_subexpr_begin:
|
|
ostr << "subexpr begin next=" << _M_next << " index=" << _M_subexpr;
|
|
break;
|
|
case _S_opcode_subexpr_end:
|
|
ostr << "subexpr end next=" << _M_next << " index=" << _M_subexpr;
|
|
break;
|
|
case _S_opcode_backref:
|
|
ostr << "backref next=" << _M_next << " index=" << _M_backref_index;
|
|
break;
|
|
case _S_opcode_match:
|
|
ostr << "match next=" << _M_next;
|
|
break;
|
|
case _S_opcode_accept:
|
|
ostr << "accept next=" << _M_next;
|
|
break;
|
|
default:
|
|
ostr << "unknown next=" << _M_next;
|
|
break;
|
|
}
|
|
return ostr;
|
|
}
|
|
|
|
// Prints graphviz dot commands for state.
|
|
inline std::ostream&
|
|
_State_base::_M_dot(std::ostream& __ostr, _StateIdT __id) const
|
|
{
|
|
switch (_M_opcode)
|
|
{
|
|
case _S_opcode_alternative:
|
|
case _S_opcode_repeat:
|
|
__ostr << __id << " [label=\"" << __id << "\\nALT\"];\n"
|
|
<< __id << " -> " << _M_next
|
|
<< " [label=\"next\", tailport=\"s\"];\n"
|
|
<< __id << " -> " << _M_alt
|
|
<< " [label=\"alt\", tailport=\"n\"];\n";
|
|
break;
|
|
case _S_opcode_backref:
|
|
__ostr << __id << " [label=\"" << __id << "\\nBACKREF "
|
|
<< _M_subexpr << "\"];\n"
|
|
<< __id << " -> " << _M_next << " [label=\"<match>\"];\n";
|
|
break;
|
|
case _S_opcode_line_begin_assertion:
|
|
__ostr << __id << " [label=\"" << __id << "\\nLINE_BEGIN \"];\n"
|
|
<< __id << " -> " << _M_next << " [label=\"epsilon\"];\n";
|
|
break;
|
|
case _S_opcode_line_end_assertion:
|
|
__ostr << __id << " [label=\"" << __id << "\\nLINE_END \"];\n"
|
|
<< __id << " -> " << _M_next << " [label=\"epsilon\"];\n";
|
|
break;
|
|
case _S_opcode_word_boundary:
|
|
__ostr << __id << " [label=\"" << __id << "\\nWORD_BOUNDRY "
|
|
<< _M_neg << "\"];\n"
|
|
<< __id << " -> " << _M_next << " [label=\"epsilon\"];\n";
|
|
break;
|
|
case _S_opcode_subexpr_lookahead:
|
|
__ostr << __id << " [label=\"" << __id << "\\nLOOK_AHEAD\"];\n"
|
|
<< __id << " -> " << _M_next
|
|
<< " [label=\"epsilon\", tailport=\"s\"];\n"
|
|
<< __id << " -> " << _M_alt
|
|
<< " [label=\"<assert>\", tailport=\"n\"];\n";
|
|
break;
|
|
case _S_opcode_subexpr_begin:
|
|
__ostr << __id << " [label=\"" << __id << "\\nSBEGIN "
|
|
<< _M_subexpr << "\"];\n"
|
|
<< __id << " -> " << _M_next << " [label=\"epsilon\"];\n";
|
|
break;
|
|
case _S_opcode_subexpr_end:
|
|
__ostr << __id << " [label=\"" << __id << "\\nSEND "
|
|
<< _M_subexpr << "\"];\n"
|
|
<< __id << " -> " << _M_next << " [label=\"epsilon\"];\n";
|
|
break;
|
|
case _S_opcode_dummy:
|
|
break;
|
|
case _S_opcode_match:
|
|
__ostr << __id << " [label=\"" << __id << "\\nMATCH\"];\n"
|
|
<< __id << " -> " << _M_next << " [label=\"<match>\"];\n";
|
|
break;
|
|
case _S_opcode_accept:
|
|
__ostr << __id << " [label=\"" << __id << "\\nACC\"];\n" ;
|
|
break;
|
|
default:
|
|
_GLIBCXX_DEBUG_ASSERT(false);
|
|
break;
|
|
}
|
|
return __ostr;
|
|
}
|
|
|
|
template<typename _TraitsT>
|
|
std::ostream&
|
|
_NFA<_TraitsT>::_M_dot(std::ostream& __ostr) const
|
|
{
|
|
__ostr << "digraph _Nfa {\n"
|
|
" rankdir=LR;\n";
|
|
for (size_t __i = 0; __i < this->size(); ++__i)
|
|
(*this)[__i]._M_dot(__ostr, __i);
|
|
__ostr << "}\n";
|
|
return __ostr;
|
|
}
|
|
#endif
|
|
|
|
template<typename _TraitsT>
|
|
_StateIdT
|
|
_NFA<_TraitsT>::_M_insert_backref(size_t __index)
|
|
{
|
|
// To figure out whether a backref is valid, a stack is used to store
|
|
// unfinished sub-expressions. For example, when parsing
|
|
// "(a(b)(c\\1(d)))" at '\\1', _M_subexpr_count is 3, indicating that 3
|
|
// sub expressions are parsed or partially parsed(in the stack), aka,
|
|
// "(a..", "(b)" and "(c..").
|
|
// _M_paren_stack is {1, 3}, for incomplete "(a.." and "(c..". At this
|
|
// time, "\\2" is valid, but "\\1" and "\\3" are not.
|
|
if (__index >= _M_subexpr_count)
|
|
__throw_regex_error(regex_constants::error_backref);
|
|
for (auto __it : this->_M_paren_stack)
|
|
if (__index == __it)
|
|
__throw_regex_error(regex_constants::error_backref);
|
|
this->_M_has_backref = true;
|
|
_StateT __tmp(_S_opcode_backref);
|
|
__tmp._M_backref_index = __index;
|
|
return _M_insert_state(std::move(__tmp));
|
|
}
|
|
|
|
template<typename _TraitsT>
|
|
void
|
|
_NFA<_TraitsT>::_M_eliminate_dummy()
|
|
{
|
|
for (auto& __it : *this)
|
|
{
|
|
while (__it._M_next >= 0 && (*this)[__it._M_next]._M_opcode
|
|
== _S_opcode_dummy)
|
|
__it._M_next = (*this)[__it._M_next]._M_next;
|
|
if (__it._M_opcode == _S_opcode_alternative
|
|
|| __it._M_opcode == _S_opcode_repeat
|
|
|| __it._M_opcode == _S_opcode_subexpr_lookahead)
|
|
while (__it._M_alt >= 0 && (*this)[__it._M_alt]._M_opcode
|
|
== _S_opcode_dummy)
|
|
__it._M_alt = (*this)[__it._M_alt]._M_next;
|
|
}
|
|
}
|
|
|
|
// Just apply DFS on the sequence and re-link their links.
|
|
template<typename _TraitsT>
|
|
_StateSeq<_TraitsT>
|
|
_StateSeq<_TraitsT>::_M_clone()
|
|
{
|
|
std::map<_StateIdT, _StateIdT> __m;
|
|
std::stack<_StateIdT> __stack;
|
|
__stack.push(_M_start);
|
|
while (!__stack.empty())
|
|
{
|
|
auto __u = __stack.top();
|
|
__stack.pop();
|
|
auto __dup = _M_nfa[__u];
|
|
// _M_insert_state() never return -1
|
|
auto __id = _M_nfa._M_insert_state(__dup);
|
|
__m[__u] = __id;
|
|
if (__dup._M_opcode == _S_opcode_alternative
|
|
|| __dup._M_opcode == _S_opcode_repeat
|
|
|| __dup._M_opcode == _S_opcode_subexpr_lookahead)
|
|
if (__dup._M_alt != _S_invalid_state_id
|
|
&& __m.count(__dup._M_alt) == 0)
|
|
__stack.push(__dup._M_alt);
|
|
if (__u == _M_end)
|
|
continue;
|
|
if (__dup._M_next != _S_invalid_state_id
|
|
&& __m.count(__dup._M_next) == 0)
|
|
__stack.push(__dup._M_next);
|
|
}
|
|
for (auto __it : __m)
|
|
{
|
|
auto __v = __it.second;
|
|
auto& __ref = _M_nfa[__v];
|
|
if (__ref._M_next != _S_invalid_state_id)
|
|
{
|
|
_GLIBCXX_DEBUG_ASSERT(__m.count(__ref._M_next) > 0);
|
|
__ref._M_next = __m[__ref._M_next];
|
|
}
|
|
if (__ref._M_opcode == _S_opcode_alternative
|
|
|| __ref._M_opcode == _S_opcode_repeat
|
|
|| __ref._M_opcode == _S_opcode_subexpr_lookahead)
|
|
if (__ref._M_alt != _S_invalid_state_id)
|
|
{
|
|
_GLIBCXX_DEBUG_ASSERT(__m.count(__ref._M_alt) > 0);
|
|
__ref._M_alt = __m[__ref._M_alt];
|
|
}
|
|
}
|
|
return _StateSeq(_M_nfa, __m[_M_start], __m[_M_end]);
|
|
}
|
|
|
|
_GLIBCXX_END_NAMESPACE_VERSION
|
|
} // namespace __detail
|
|
} // namespace
|