X-Git-Url: http://wagnertech.de/git?a=blobdiff_plain;f=i686-linux-gnu-4.7%2Fusr%2Finclude%2Fc%2B%2B%2F4.7%2Fbits%2Fregex_nfa.h;fp=i686-linux-gnu-4.7%2Fusr%2Finclude%2Fc%2B%2B%2F4.7%2Fbits%2Fregex_nfa.h;h=c4a65e6722ddb3871d520d19feef62bc5fa4e825;hb=94df942c2c7bd3457276fe5b7367623cbb8c1302;hp=0000000000000000000000000000000000000000;hpb=4dd7d9155a920895ff7b1cb6b9c9c676aa62000a;p=cross.git diff --git a/i686-linux-gnu-4.7/usr/include/c++/4.7/bits/regex_nfa.h b/i686-linux-gnu-4.7/usr/include/c++/4.7/bits/regex_nfa.h new file mode 100644 index 0000000..c4a65e6 --- /dev/null +++ b/i686-linux-gnu-4.7/usr/include/c++/4.7/bits/regex_nfa.h @@ -0,0 +1,400 @@ +// class template regex -*- C++ -*- + +// Copyright (C) 2010, 2011 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 +// . + +/** + * @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 __regex +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + // 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 _Tagger; + + template + 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; + }; + + template + 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 _Matcher; + + // Matches any character + inline bool + _AnyMatcher(const _PatternCursor&) + { return true; } + + // Matches a single character + template + 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 + 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; + + + // 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; + + // 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; + + public: + _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; + + }; + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace __regex +} // namespace std + +#include +