regex.h (regex_token_iterator<>::regex_token_iterator): Fix initialization orders...

[gcc.git] / libstdc++-v3 / include / bits / regex_compiler.h

diff --git a/libstdc++-v3/include/bits/regex_compiler.h b/libstdc++-v3/include/bits/regex_compiler.h
index a1107bb7eeb632756c06ccfbb42671a4fa0d9aaa..7e4e6adafd56f8d2f25fd0c0accb6a79853d3229 100644 (file)
--- a/libstdc++-v3/include/bits/regex_compiler.h
+++ b/libstdc++-v3/include/bits/regex_compiler.h
@@ -56,7 +56,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
       std::shared_ptr<_RegexT>
       _M_get_nfa() const
-      { return std::shared_ptr<_RegexT>(new _RegexT(_M_state_store)); }
+      { return make_shared<_RegexT>(_M_nfa); }
 
     private:
       typedef _Scanner<_FwdIter>                              _ScannerT;
@@ -64,6 +64,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       typedef _StateSeq<_CharT, _TraitsT>                     _StateSeqT;
       typedef std::stack<_StateSeqT, std::vector<_StateSeqT>> _StackT;
       typedef _BracketMatcher<_CharT, _TraitsT>               _BMatcherT;
+      typedef std::ctype<_CharT>                              _CtypeT;
 
       // accepts a specific token or returns false.
       bool
@@ -90,21 +91,12 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       bool
       _M_bracket_expression();
 
-      void
-      _M_bracket_list(_BMatcherT& __matcher);
-
-      bool
-      _M_follow_list(_BMatcherT& __matcher);
-
       void
       _M_expression_term(_BMatcherT& __matcher);
 
       bool
       _M_range_expression(_BMatcherT& __matcher);
 
-      bool
-      _M_start_range(_BMatcherT& __matcher);
-
       bool
       _M_collating_symbol(_BMatcherT& __matcher);
 
@@ -120,15 +112,69 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       bool
       _M_try_char();
 
-      _CharT
-      _M_get_char();
+      _StateSeqT
+      _M_pop()
+      {
+       auto ret = _M_stack.top();
+       _M_stack.pop();
+       return ret;
+      }
 
+      _FlagT          _M_flags;
       const _TraitsT& _M_traits;
+      const _CtypeT&  _M_ctype;
       _ScannerT       _M_scanner;
+      _RegexT         _M_nfa;
       _StringT        _M_value;
-      _RegexT         _M_state_store;
       _StackT         _M_stack;
+    };
+
+  template<typename _CharT, typename _TraitsT>
+    struct _AnyMatcher
+    {
+      explicit
+      _AnyMatcher(const _TraitsT& __traits)
+      : _M_traits(__traits)
+      { }
+
+      bool
+      operator()(_CharT __ch) const
+      {
+       return _M_traits.translate(__ch) != '\n'
+         && _M_traits.translate(__ch) != '\r'
+         && _M_traits.translate(__ch) != u'\u2028'
+         && _M_traits.translate(__ch) != u'\u2029';
+      }
+
+      const _TraitsT& _M_traits;
+    };
+
+  template<typename _CharT, typename _TraitsT>
+    struct _CharMatcher
+    {
+      typedef regex_constants::syntax_option_type _FlagT;
+
+      explicit
+      _CharMatcher(_CharT __ch, const _TraitsT& __traits, _FlagT __flags)
+      : _M_traits(__traits), _M_flags(__flags), _M_ch(_M_translate(__ch))
+      { }
+
+      bool
+      operator()(_CharT __ch) const
+      { return _M_ch == _M_translate(__ch); }
+
+      _CharT
+      _M_translate(_CharT __ch) const
+      {
+       if (_M_flags & regex_constants::icase)
+         return _M_traits.translate_nocase(__ch);
+       else
+         return _M_traits.translate(__ch);
+      }
+
+      const _TraitsT& _M_traits;
       _FlagT          _M_flags;
+      _CharT          _M_ch;
     };
 
   /// Matches a character range (bracket expression)
@@ -141,10 +187,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
       explicit
       _BracketMatcher(bool __is_non_matching,
-                     const _TraitsT& __t,
+                     const _TraitsT& __traits,
                      _FlagT __flags)
-      : _M_is_non_matching(__is_non_matching), _M_traits(__t),
-       _M_flags(__flags), _M_class_set(0)
+      : _M_traits(__traits), _M_class_set(0), _M_flags(__flags),
+      _M_is_non_matching(__is_non_matching)
       { }
 
       bool
@@ -152,7 +198,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
       void
       _M_add_char(_CharT __c)
-      { _M_char_set.push_back(_M_translate(__c)); }
+      { _M_char_set.insert(_M_translate(__c)); }
 
       void
       _M_add_collating_element(const _StringT& __s)
@@ -161,46 +207,50 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
                                                 __s.data() + __s.size());
        if (__st.empty())
          __throw_regex_error(regex_constants::error_collate);
-       // TODO: digraph
-       _M_char_set.push_back(__st[0]);
+       _M_char_set.insert(_M_translate(__st[0]));
       }
 
       void
       _M_add_equivalence_class(const _StringT& __s)
       {
-       _M_add_character_class(
-         _M_traits.transform_primary(__s.data(),
-                                     __s.data() + __s.size()));
+       auto __st = _M_traits.lookup_collatename(__s.data(),
+                                                __s.data() + __s.size());
+       if (__st.empty())
+         __throw_regex_error(regex_constants::error_collate);
+       __st = _M_traits.transform_primary(__st.data(),
+                                          __st.data() + __st.size());
+       _M_equiv_set.insert(__st);
       }
 
       void
       _M_add_character_class(const _StringT& __s)
       {
-       auto __st = _M_traits.
-         lookup_classname(__s.data(), __s.data() + __s.size(), _M_is_icase());
-       if (__st == 0)
+       auto __mask = _M_traits.lookup_classname(__s.data(),
+                                                __s.data() + __s.size(),
+                                                _M_is_icase());
+       if (__mask == 0)
          __throw_regex_error(regex_constants::error_ctype);
-       _M_class_set |= __st;
+       _M_class_set |= __mask;
       }
 
       void
       _M_make_range(_CharT __l, _CharT __r)
       {
-       _M_range_set.push_back(
-         make_pair(_M_get_str(_M_translate(__l)),
-                   _M_get_str(_M_translate(__r))));
+       if (_M_flags & regex_constants::collate)
+         _M_range_set.insert(
+           make_pair(_M_get_str(_M_translate(__l)),
+                     _M_get_str(_M_translate(__r))));
+       else
+         _M_range_set.insert(make_pair(_M_get_str(__l), _M_get_str(__r)));
       }
 
       _CharT
       _M_translate(_CharT __c) const
       {
-       if (_M_flags & regex_constants::collate)
-         if (_M_is_icase())
-           return _M_traits.translate_nocase(__c);
-         else
-           return _M_traits.translate(__c);
+       if (_M_is_icase())
+         return _M_traits.translate_nocase(__c);
        else
-         return __c;
+         return _M_traits.translate(__c);
       }
 
       bool
@@ -214,12 +264,13 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
        return _M_traits.transform(__s.begin(), __s.end());
       }
 
-      const _TraitsT&                       _M_traits;
-      _FlagT                                _M_flags;
-      bool                                  _M_is_non_matching;
-      std::vector<_CharT>                   _M_char_set;
-      std::vector<pair<_StringT, _StringT>> _M_range_set;
-      _CharClassT                           _M_class_set;
+      std::set<_CharT>                   _M_char_set;
+      std::set<_StringT>                 _M_equiv_set;
+      std::set<pair<_StringT, _StringT>> _M_range_set;
+      const _TraitsT&                    _M_traits;
+      _CharClassT                        _M_class_set;
+      _FlagT                             _M_flags;
+      bool                               _M_is_non_matching;
     };
 
  //@} regex-detail