Edit File: regex_nfa.h
// class template regex -*- C++ -*- // Copyright (C) 2010-2013 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_nfa.h * 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 /** * @addtogroup regex-detail * @{ */ /// Base class for, um, automata. Could be an NFA or a DFA. Your choice. class _Automaton { public: typedef unsigned int _SizeT; public: virtual ~_Automaton() { } virtual _SizeT _M_sub_count() const = 0; #ifdef _GLIBCXX_DEBUG virtual std::ostream& _M_dot(std::ostream& __ostr) const = 0; #endif }; /// Generic shared pointer to an automaton. typedef std::shared_ptr<_Automaton> _AutomatonPtr; /// Operation codes that define the type of transitions within the base NFA /// that represents the regular expression. enum _Opcode { _S_opcode_unknown = 0, _S_opcode_alternative = 1, _S_opcode_subexpr_begin = 4, _S_opcode_subexpr_end = 5, _S_opcode_match = 100, _S_opcode_accept = 255 }; /// Provides a generic facade for a templated match_results. struct _Results { virtual void _M_set_pos(int __i, int __j, const _PatternCursor& __p) = 0; virtual void _M_set_matched(int __i, bool __is_matched) = 0; }; /// Tags current state (for subexpr begin/end). typedef std::function<void (const _PatternCursor&, _Results&)> _Tagger; /// Start state tag. template<typename _FwdIterT, typename _TraitsT> struct _StartTagger { explicit _StartTagger(int __i) : _M_index(__i) { } void operator()(const _PatternCursor& __pc, _Results& __r) { __r._M_set_pos(_M_index, 0, __pc); } int _M_index; }; /// End state tag. template<typename _FwdIterT, typename _TraitsT> struct _EndTagger { explicit _EndTagger(int __i) : _M_index(__i) { } void operator()(const _PatternCursor& __pc, _Results& __r) { __r._M_set_pos(_M_index, 1, __pc); } int _M_index; _FwdIterT _M_pos; }; /// Indicates if current state matches cursor current. typedef std::function<bool (const _PatternCursor&)> _Matcher; /// Matches any character inline bool _AnyMatcher(const _PatternCursor&) { return true; } /// Matches a single character template<typename _InIterT, typename _TraitsT> struct _CharMatcher { typedef typename _TraitsT::char_type char_type; explicit _CharMatcher(char_type __c, const _TraitsT& __t = _TraitsT()) : _M_traits(__t), _M_c(_M_traits.translate(__c)) { } bool operator()(const _PatternCursor& __pc) const { typedef const _SpecializedCursor<_InIterT>& _CursorT; _CursorT __c = static_cast<_CursorT>(__pc); return _M_traits.translate(__c._M_current()) == _M_c; } const _TraitsT& _M_traits; char_type _M_c; }; /// Matches a character range (bracket expression) template<typename _InIterT, typename _TraitsT> struct _RangeMatcher { typedef typename _TraitsT::char_type _CharT; typedef std::basic_string<_CharT> _StringT; explicit _RangeMatcher(bool __is_non_matching, const _TraitsT& __t = _TraitsT()) : _M_traits(__t), _M_is_non_matching(__is_non_matching) { } bool operator()(const _PatternCursor& __pc) const { typedef const _SpecializedCursor<_InIterT>& _CursorT; _CursorT __c = static_cast<_CursorT>(__pc); return true; } void _M_add_char(_CharT __c) { } void _M_add_collating_element(const _StringT& __s) { } void _M_add_equivalence_class(const _StringT& __s) { } void _M_add_character_class(const _StringT& __s) { } void _M_make_range() { } const _TraitsT& _M_traits; bool _M_is_non_matching; }; /// Identifies a state in the NFA. typedef int _StateIdT; /// The special case in which a state identifier is not an index. static const _StateIdT _S_invalid_state_id = -1; /** * @brief struct _State * * An individual state in an NFA * * In this case a "state" is an entry in the NFA definition coupled * with its outgoing transition(s). All states have a single outgoing * transition, except for accepting states (which have no outgoing * transitions) and alt states, which have two outgoing transitions. */ struct _State { typedef int _OpcodeT; _OpcodeT _M_opcode; // type of outgoing transition _StateIdT _M_next; // outgoing transition _StateIdT _M_alt; // for _S_opcode_alternative unsigned int _M_subexpr; // for _S_opcode_subexpr_* _Tagger _M_tagger; // for _S_opcode_subexpr_* _Matcher _M_matches; // for _S_opcode_match explicit _State(_OpcodeT __opcode) : _M_opcode(__opcode), _M_next(_S_invalid_state_id) { } _State(const _Matcher& __m) : _M_opcode(_S_opcode_match), _M_next(_S_invalid_state_id), _M_matches(__m) { } _State(_OpcodeT __opcode, unsigned int __s, const _Tagger& __t) : _M_opcode(__opcode), _M_next(_S_invalid_state_id), _M_subexpr(__s), _M_tagger(__t) { } _State(_StateIdT __next, _StateIdT __alt) : _M_opcode(_S_opcode_alternative), _M_next(__next), _M_alt(__alt) { } #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 }; /// The Grep Matcher works on sets of states. Here are sets of states. typedef std::set<_StateIdT> _StateSet; /** * @brief struct _Nfa * * A collection of all states making up an NFA. * * An NFA is a 4-tuple M = (K, S, s, F), where * K is a finite set of states, * S is the alphabet of the NFA, * s is the initial state, * F is a set of final (accepting) states. * * This NFA class is templated on S, a type that will hold values of the * underlying alphabet (without regard to semantics of that alphabet). The * other elements of the tuple are generated during construction of the NFA * and are available through accessor member functions. */ class _Nfa : public _Automaton, public std::vector<_State> { public: typedef _State _StateT; typedef unsigned int _SizeT; typedef regex_constants::syntax_option_type _FlagT; _Nfa(_FlagT __f) : _M_flags(__f), _M_start_state(0), _M_subexpr_count(0) { } ~_Nfa() { } _FlagT _M_options() const { return _M_flags; } _StateIdT _M_start() const { return _M_start_state; } const _StateSet& _M_final_states() const { return _M_accepting_states; } _SizeT _M_sub_count() const { return _M_subexpr_count; } _StateIdT _M_insert_accept() { this->push_back(_StateT(_S_opcode_accept)); _M_accepting_states.insert(this->size()-1); return this->size()-1; } _StateIdT _M_insert_alt(_StateIdT __next, _StateIdT __alt) { this->push_back(_StateT(__next, __alt)); return this->size()-1; } _StateIdT _M_insert_matcher(_Matcher __m) { this->push_back(_StateT(__m)); return this->size()-1; } _StateIdT _M_insert_subexpr_begin(const _Tagger& __t) { this->push_back(_StateT(_S_opcode_subexpr_begin, _M_subexpr_count++, __t)); return this->size()-1; } _StateIdT _M_insert_subexpr_end(unsigned int __i, const _Tagger& __t) { this->push_back(_StateT(_S_opcode_subexpr_end, __i, __t)); return this->size()-1; } #ifdef _GLIBCXX_DEBUG std::ostream& _M_dot(std::ostream& __ostr) const; #endif private: _FlagT _M_flags; _StateIdT _M_start_state; _StateSet _M_accepting_states; _SizeT _M_subexpr_count; }; /// Describes a sequence of one or more %_State, its current start /// and end(s). This structure contains fragments of an NFA during /// construction. class _StateSeq { public: // Constructs a single-node sequence _StateSeq(_Nfa& __ss, _StateIdT __s, _StateIdT __e = _S_invalid_state_id) : _M_nfa(__ss), _M_start(__s), _M_end1(__s), _M_end2(__e) { } // Constructs a split sequence from two other sequencces _StateSeq(const _StateSeq& __e1, const _StateSeq& __e2) : _M_nfa(__e1._M_nfa), _M_start(_M_nfa._M_insert_alt(__e1._M_start, __e2._M_start)), _M_end1(__e1._M_end1), _M_end2(__e2._M_end1) { } // Constructs a split sequence from a single sequence _StateSeq(const _StateSeq& __e, _StateIdT __id) : _M_nfa(__e._M_nfa), _M_start(_M_nfa._M_insert_alt(__id, __e._M_start)), _M_end1(__id), _M_end2(__e._M_end1) { } // Constructs a copy of a %_StateSeq _StateSeq(const _StateSeq& __rhs) : _M_nfa(__rhs._M_nfa), _M_start(__rhs._M_start), _M_end1(__rhs._M_end1), _M_end2(__rhs._M_end2) { } _StateSeq& operator=(const _StateSeq& __rhs); _StateIdT _M_front() const { return _M_start; } // Extends a sequence by one. void _M_push_back(_StateIdT __id); // Extends and maybe joins a sequence. void _M_append(_StateIdT __id); void _M_append(_StateSeq& __rhs); // Clones an entire sequence. _StateIdT _M_clone(); private: _Nfa& _M_nfa; _StateIdT _M_start; _StateIdT _M_end1; _StateIdT _M_end2; }; //@} regex-detail _GLIBCXX_END_NAMESPACE_VERSION } // namespace __detail } // namespace std #include <bits/regex_nfa.tcc>