331 lines
8.5 KiB
C++
331 lines
8.5 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.h
|
|
* This is an internal header file, included by other library headers.
|
|
* Do not attempt to use it directly. @headername{regex}
|
|
*/
|
|
|
|
// This macro defines the maximal state number a NFA can have.
|
|
#ifndef _GLIBCXX_REGEX_STATE_LIMIT
|
|
#define _GLIBCXX_REGEX_STATE_LIMIT 100000
|
|
#endif
|
|
|
|
namespace std _GLIBCXX_VISIBILITY(default)
|
|
{
|
|
namespace __detail
|
|
{
|
|
_GLIBCXX_BEGIN_NAMESPACE_VERSION
|
|
|
|
/**
|
|
* @defgroup regex-detail Base and Implementation Classes
|
|
* @ingroup regex
|
|
* @{
|
|
*/
|
|
|
|
typedef long _StateIdT;
|
|
static const _StateIdT _S_invalid_state_id = -1;
|
|
|
|
template<typename _CharT>
|
|
using _Matcher = std::function<bool (_CharT)>;
|
|
|
|
/// Operation codes that define the type of transitions within the base NFA
|
|
/// that represents the regular expression.
|
|
enum _Opcode : int
|
|
{
|
|
_S_opcode_unknown,
|
|
_S_opcode_alternative,
|
|
_S_opcode_repeat,
|
|
_S_opcode_backref,
|
|
_S_opcode_line_begin_assertion,
|
|
_S_opcode_line_end_assertion,
|
|
_S_opcode_word_boundary,
|
|
_S_opcode_subexpr_lookahead,
|
|
_S_opcode_subexpr_begin,
|
|
_S_opcode_subexpr_end,
|
|
_S_opcode_dummy,
|
|
_S_opcode_match,
|
|
_S_opcode_accept,
|
|
};
|
|
|
|
struct _State_base
|
|
{
|
|
_Opcode _M_opcode; // type of outgoing transition
|
|
_StateIdT _M_next; // outgoing transition
|
|
union // Since they are mutually exclusive.
|
|
{
|
|
size_t _M_subexpr; // for _S_opcode_subexpr_*
|
|
size_t _M_backref_index; // for _S_opcode_backref
|
|
struct
|
|
{
|
|
// for _S_opcode_alternative, _S_opcode_repeat and
|
|
// _S_opcode_subexpr_lookahead
|
|
_StateIdT _M_alt;
|
|
// for _S_opcode_word_boundary or _S_opcode_subexpr_lookahead or
|
|
// quantifiers (ungreedy if set true)
|
|
bool _M_neg;
|
|
};
|
|
};
|
|
|
|
explicit _State_base(_Opcode __opcode)
|
|
: _M_opcode(__opcode), _M_next(_S_invalid_state_id)
|
|
{ }
|
|
|
|
protected:
|
|
~_State_base() = default;
|
|
|
|
public:
|
|
#ifdef _GLIBCXX_DEBUG
|
|
std::ostream&
|
|
_M_print(std::ostream& ostr) const;
|
|
|
|
// Prints graphviz dot commands for state.
|
|
std::ostream&
|
|
_M_dot(std::ostream& __ostr, _StateIdT __id) const;
|
|
#endif
|
|
};
|
|
|
|
template<typename _TraitsT>
|
|
struct _State : _State_base
|
|
{
|
|
typedef _Matcher<typename _TraitsT::char_type> _MatcherT;
|
|
|
|
_MatcherT _M_matches; // for _S_opcode_match
|
|
|
|
explicit _State(_Opcode __opcode) : _State_base(__opcode) { }
|
|
};
|
|
|
|
struct _NFA_base
|
|
{
|
|
typedef size_t _SizeT;
|
|
typedef regex_constants::syntax_option_type _FlagT;
|
|
|
|
explicit
|
|
_NFA_base(_FlagT __f)
|
|
: _M_flags(__f), _M_start_state(0), _M_subexpr_count(0),
|
|
_M_has_backref(false)
|
|
{ }
|
|
|
|
_NFA_base(_NFA_base&&) = default;
|
|
|
|
protected:
|
|
~_NFA_base() = default;
|
|
|
|
public:
|
|
_FlagT
|
|
_M_options() const
|
|
{ return _M_flags; }
|
|
|
|
_StateIdT
|
|
_M_start() const
|
|
{ return _M_start_state; }
|
|
|
|
_SizeT
|
|
_M_sub_count() const
|
|
{ return _M_subexpr_count; }
|
|
|
|
std::vector<size_t> _M_paren_stack;
|
|
_FlagT _M_flags;
|
|
_StateIdT _M_start_state;
|
|
_SizeT _M_subexpr_count;
|
|
bool _M_has_backref;
|
|
};
|
|
|
|
template<typename _TraitsT>
|
|
struct _NFA
|
|
: _NFA_base, std::vector<_State<_TraitsT>>
|
|
{
|
|
typedef _State<_TraitsT> _StateT;
|
|
typedef _Matcher<typename _TraitsT::char_type> _MatcherT;
|
|
|
|
_NFA(const typename _TraitsT::locale_type& __loc, _FlagT __flags)
|
|
: _NFA_base(__flags)
|
|
{ _M_traits.imbue(__loc); }
|
|
|
|
// for performance reasons _NFA objects should only be moved not copied
|
|
_NFA(const _NFA&) = delete;
|
|
_NFA(_NFA&&) = default;
|
|
|
|
_StateIdT
|
|
_M_insert_accept()
|
|
{
|
|
auto __ret = _M_insert_state(_StateT(_S_opcode_accept));
|
|
return __ret;
|
|
}
|
|
|
|
_StateIdT
|
|
_M_insert_alt(_StateIdT __next, _StateIdT __alt, bool __neg)
|
|
{
|
|
_StateT __tmp(_S_opcode_alternative);
|
|
// It labels every quantifier to make greedy comparison easier in BFS
|
|
// approach.
|
|
__tmp._M_next = __next;
|
|
__tmp._M_alt = __alt;
|
|
return _M_insert_state(std::move(__tmp));
|
|
}
|
|
|
|
_StateIdT
|
|
_M_insert_repeat(_StateIdT __next, _StateIdT __alt, bool __neg)
|
|
{
|
|
_StateT __tmp(_S_opcode_repeat);
|
|
// It labels every quantifier to make greedy comparison easier in BFS
|
|
// approach.
|
|
__tmp._M_next = __next;
|
|
__tmp._M_alt = __alt;
|
|
__tmp._M_neg = __neg;
|
|
return _M_insert_state(std::move(__tmp));
|
|
}
|
|
|
|
_StateIdT
|
|
_M_insert_matcher(_MatcherT __m)
|
|
{
|
|
_StateT __tmp(_S_opcode_match);
|
|
__tmp._M_matches = std::move(__m);
|
|
return _M_insert_state(std::move(__tmp));
|
|
}
|
|
|
|
_StateIdT
|
|
_M_insert_subexpr_begin()
|
|
{
|
|
auto __id = this->_M_subexpr_count++;
|
|
this->_M_paren_stack.push_back(__id);
|
|
_StateT __tmp(_S_opcode_subexpr_begin);
|
|
__tmp._M_subexpr = __id;
|
|
return _M_insert_state(std::move(__tmp));
|
|
}
|
|
|
|
_StateIdT
|
|
_M_insert_subexpr_end()
|
|
{
|
|
_StateT __tmp(_S_opcode_subexpr_end);
|
|
__tmp._M_subexpr = this->_M_paren_stack.back();
|
|
this->_M_paren_stack.pop_back();
|
|
return _M_insert_state(std::move(__tmp));
|
|
}
|
|
|
|
_StateIdT
|
|
_M_insert_backref(size_t __index);
|
|
|
|
_StateIdT
|
|
_M_insert_line_begin()
|
|
{ return _M_insert_state(_StateT(_S_opcode_line_begin_assertion)); }
|
|
|
|
_StateIdT
|
|
_M_insert_line_end()
|
|
{ return _M_insert_state(_StateT(_S_opcode_line_end_assertion)); }
|
|
|
|
_StateIdT
|
|
_M_insert_word_bound(bool __neg)
|
|
{
|
|
_StateT __tmp(_S_opcode_word_boundary);
|
|
__tmp._M_neg = __neg;
|
|
return _M_insert_state(std::move(__tmp));
|
|
}
|
|
|
|
_StateIdT
|
|
_M_insert_lookahead(_StateIdT __alt, bool __neg)
|
|
{
|
|
_StateT __tmp(_S_opcode_subexpr_lookahead);
|
|
__tmp._M_alt = __alt;
|
|
__tmp._M_neg = __neg;
|
|
return _M_insert_state(std::move(__tmp));
|
|
}
|
|
|
|
_StateIdT
|
|
_M_insert_dummy()
|
|
{ return _M_insert_state(_StateT(_S_opcode_dummy)); }
|
|
|
|
_StateIdT
|
|
_M_insert_state(_StateT __s)
|
|
{
|
|
this->push_back(std::move(__s));
|
|
if (this->size() > _GLIBCXX_REGEX_STATE_LIMIT)
|
|
__throw_regex_error(regex_constants::error_space);
|
|
return this->size()-1;
|
|
}
|
|
|
|
// Eliminate dummy node in this NFA to make it compact.
|
|
void
|
|
_M_eliminate_dummy();
|
|
|
|
#ifdef _GLIBCXX_DEBUG
|
|
std::ostream&
|
|
_M_dot(std::ostream& __ostr) const;
|
|
#endif
|
|
public:
|
|
_TraitsT _M_traits;
|
|
};
|
|
|
|
/// Describes a sequence of one or more %_State, its current start
|
|
/// and end(s). This structure contains fragments of an NFA during
|
|
/// construction.
|
|
template<typename _TraitsT>
|
|
class _StateSeq
|
|
{
|
|
public:
|
|
typedef _NFA<_TraitsT> _RegexT;
|
|
|
|
public:
|
|
_StateSeq(_RegexT& __nfa, _StateIdT __s)
|
|
: _M_nfa(__nfa), _M_start(__s), _M_end(__s)
|
|
{ }
|
|
|
|
_StateSeq(_RegexT& __nfa, _StateIdT __s, _StateIdT __end)
|
|
: _M_nfa(__nfa), _M_start(__s), _M_end(__end)
|
|
{ }
|
|
|
|
// Append a state on *this and change *this to the new sequence.
|
|
void
|
|
_M_append(_StateIdT __id)
|
|
{
|
|
_M_nfa[_M_end]._M_next = __id;
|
|
_M_end = __id;
|
|
}
|
|
|
|
// Append a sequence on *this and change *this to the new sequence.
|
|
void
|
|
_M_append(const _StateSeq& __s)
|
|
{
|
|
_M_nfa[_M_end]._M_next = __s._M_start;
|
|
_M_end = __s._M_end;
|
|
}
|
|
|
|
// Clones an entire sequence.
|
|
_StateSeq
|
|
_M_clone();
|
|
|
|
public:
|
|
_RegexT& _M_nfa;
|
|
_StateIdT _M_start;
|
|
_StateIdT _M_end;
|
|
};
|
|
|
|
//@} regex-detail
|
|
_GLIBCXX_END_NAMESPACE_VERSION
|
|
} // namespace __detail
|
|
} // namespace std
|
|
|
|
#include <bits/regex_automaton.tcc>
|