Split _M_dfs() into smaller functions.

	* regex_executor.h(_M_handle_repeat, _M_handle_subexpr_begin)
	(_M_handle_subexpr_end, _M_handle_line_begin_assertion)
	(_M_handle_line_end_assertion, _M_handle_word_boundary)
	(_M_handle_subexpr_lookahead, _M_handle_match)
	(_M_handle_backref, _M_handle_accept, _M_handle_alternative):
	Add separate function declarations.
	* regex_executor.tcc: Split _M_dfs() into multiple handler functions.

From-SVN: r239673

libstdc++-v3/ChangeLog

+2016-08-22  Tim Shen  <timshen@google.com>
+
+	Split _M_dfs() into smaller functions.
+	* regex_executor.h(_M_handle_repeat, _M_handle_subexpr_begin)
+	(_M_handle_subexpr_end, _M_handle_line_begin_assertion)
+	(_M_handle_line_end_assertion, _M_handle_word_boundary)
+	(_M_handle_subexpr_lookahead, _M_handle_match)
+	(_M_handle_backref, _M_handle_accept, _M_handle_alternative):
+	Add separate function declarations.
+	* regex_executor.tcc: Split _M_dfs() into multiple handler functions.
+
 2016-08-22  Gleb Natapov  <gleb@scylladb.com>
 
 	PR libstdc++/68297

libstdc++-v3/include/bits/regex_executor.h

@@ -109,6 +109,39 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       _M_rep_once_more(_Match_mode __match_mode, _StateIdT);
 
       void
+      _M_handle_repeat(_Match_mode, _StateIdT);
+
+      void
+      _M_handle_subexpr_begin(_Match_mode, _StateIdT);
+
+      void
+      _M_handle_subexpr_end(_Match_mode, _StateIdT);
+
+      void
+      _M_handle_line_begin_assertion(_Match_mode, _StateIdT);
+
+      void
+      _M_handle_line_end_assertion(_Match_mode, _StateIdT);
+
+      void
+      _M_handle_word_boundary(_Match_mode, _StateIdT);
+
+      void
+      _M_handle_subexpr_lookahead(_Match_mode, _StateIdT);
+
+      void
+      _M_handle_match(_Match_mode, _StateIdT);
+
+      void
+      _M_handle_backref(_Match_mode, _StateIdT);
+
+      void
+      _M_handle_accept(_Match_mode, _StateIdT);
+
+      void
+      _M_handle_alternative(_Match_mode, _StateIdT);
+
+      void
       _M_dfs(_Match_mode __match_mode, _StateIdT __start);
 
       bool

libstdc++-v3/include/bits/regex_executor.tcc

@@ -195,25 +195,17 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	}
     };
 
-  template<typename _BiIter, typename _Alloc, typename _TraitsT,
-	   bool __dfs_mode>
-    void _Executor<_BiIter, _Alloc, _TraitsT, __dfs_mode>::
-    _M_dfs(_Match_mode __match_mode, _StateIdT __i)
-    {
-      if (_M_states._M_visited(__i))
-	return;
-
-      const auto& __state = _M_nfa[__i];
-      // Every change on _M_cur_results and _M_current will be rolled back after
-      // finishing the recursion step.
-      switch (__state._M_opcode())
-	{
   // _M_alt branch is "match once more", while _M_next is "get me out
   // of this quantifier". Executing _M_next first or _M_alt first don't
   // mean the same thing, and we need to choose the correct order under
   // given greedy mode.
-	case _S_opcode_repeat:
+  template<typename _BiIter, typename _Alloc, typename _TraitsT,
+	   bool __dfs_mode>
+    void _Executor<_BiIter, _Alloc, _TraitsT, __dfs_mode>::
+    _M_handle_repeat(_Match_mode __match_mode, _StateIdT __i)
     {
+      const auto& __state = _M_nfa[__i];
+
       // Greedy.
       if (!__state._M_neg)
 	{
@@ -248,18 +240,28 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	    }
 	}
     }
-	  break;
-	case _S_opcode_subexpr_begin:
+
+  template<typename _BiIter, typename _Alloc, typename _TraitsT,
+	   bool __dfs_mode>
+    void _Executor<_BiIter, _Alloc, _TraitsT, __dfs_mode>::
+    _M_handle_subexpr_begin(_Match_mode __match_mode, _StateIdT __i)
     {
+      const auto& __state = _M_nfa[__i];
+
       auto& __res = _M_cur_results[__state._M_subexpr];
       auto __back = __res.first;
       __res.first = _M_current;
       _M_dfs(__match_mode, __state._M_next);
       __res.first = __back;
     }
-	  break;
-	case _S_opcode_subexpr_end:
+
+  template<typename _BiIter, typename _Alloc, typename _TraitsT,
+	   bool __dfs_mode>
+    void _Executor<_BiIter, _Alloc, _TraitsT, __dfs_mode>::
+    _M_handle_subexpr_end(_Match_mode __match_mode, _StateIdT __i)
     {
+      const auto& __state = _M_nfa[__i];
+
       auto& __res = _M_cur_results[__state._M_subexpr];
       auto __back = __res;
       __res.second = _M_current;
@@ -267,28 +269,58 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       _M_dfs(__match_mode, __state._M_next);
       __res = __back;
     }
-	  break;
-	case _S_opcode_line_begin_assertion:
+
+  template<typename _BiIter, typename _Alloc, typename _TraitsT,
+	   bool __dfs_mode>
+    inline void _Executor<_BiIter, _Alloc, _TraitsT, __dfs_mode>::
+    _M_handle_line_begin_assertion(_Match_mode __match_mode, _StateIdT __i)
+    {
+      const auto& __state = _M_nfa[__i];
       if (_M_at_begin())
 	_M_dfs(__match_mode, __state._M_next);
-	  break;
-	case _S_opcode_line_end_assertion:
+    }
+
+  template<typename _BiIter, typename _Alloc, typename _TraitsT,
+	   bool __dfs_mode>
+    inline void _Executor<_BiIter, _Alloc, _TraitsT, __dfs_mode>::
+    _M_handle_line_end_assertion(_Match_mode __match_mode, _StateIdT __i)
+    {
+      const auto& __state = _M_nfa[__i];
       if (_M_at_end())
 	_M_dfs(__match_mode, __state._M_next);
-	  break;
-	case _S_opcode_word_boundary:
+    }
+
+  template<typename _BiIter, typename _Alloc, typename _TraitsT,
+	   bool __dfs_mode>
+    inline void _Executor<_BiIter, _Alloc, _TraitsT, __dfs_mode>::
+    _M_handle_word_boundary(_Match_mode __match_mode, _StateIdT __i)
+    {
+      const auto& __state = _M_nfa[__i];
       if (_M_word_boundary() == !__state._M_neg)
 	_M_dfs(__match_mode, __state._M_next);
-	  break;
+    }
+
   // Here __state._M_alt offers a single start node for a sub-NFA.
   // We recursively invoke our algorithm to match the sub-NFA.
-	case _S_opcode_subexpr_lookahead:
+  template<typename _BiIter, typename _Alloc, typename _TraitsT,
+	   bool __dfs_mode>
+    void _Executor<_BiIter, _Alloc, _TraitsT, __dfs_mode>::
+    _M_handle_subexpr_lookahead(_Match_mode __match_mode, _StateIdT __i)
+    {
+      const auto& __state = _M_nfa[__i];
       if (_M_lookahead(__state._M_alt) == !__state._M_neg)
 	_M_dfs(__match_mode, __state._M_next);
-	  break;
-	case _S_opcode_match:
+    }
+
+  template<typename _BiIter, typename _Alloc, typename _TraitsT,
+	   bool __dfs_mode>
+    void _Executor<_BiIter, _Alloc, _TraitsT, __dfs_mode>::
+    _M_handle_match(_Match_mode __match_mode, _StateIdT __i)
+    {
+      const auto& __state = _M_nfa[__i];
+
       if (_M_current == _M_end)
-	    break;
+	return;
       if (__dfs_mode)
 	{
 	  if (__state._M_matches(*_M_current))
@@ -301,17 +333,23 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       else
 	if (__state._M_matches(*_M_current))
 	  _M_states._M_queue(__state._M_next, _M_cur_results);
-	  break;
+    }
+
   // First fetch the matched result from _M_cur_results as __submatch;
   // then compare it with
   // (_M_current, _M_current + (__submatch.second - __submatch.first)).
   // If matched, keep going; else just return and try another state.
-	case _S_opcode_backref:
+  template<typename _BiIter, typename _Alloc, typename _TraitsT,
+	   bool __dfs_mode>
+    void _Executor<_BiIter, _Alloc, _TraitsT, __dfs_mode>::
+    _M_handle_backref(_Match_mode __match_mode, _StateIdT __i)
     {
       __glibcxx_assert(__dfs_mode);
+
+      const auto& __state = _M_nfa[__i];
       auto& __submatch = _M_cur_results[__state._M_backref_index];
       if (!__submatch.matched)
-	      break;
+	return;
       auto __last = _M_current;
       for (auto __tmp = __submatch.first;
 	   __last != _M_end && __tmp != __submatch.second;
@@ -332,8 +370,12 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	    _M_dfs(__match_mode, __state._M_next);
 	}
     }
-	  break;
-	case _S_opcode_accept:
+
+  template<typename _BiIter, typename _Alloc, typename _TraitsT,
+	   bool __dfs_mode>
+    void _Executor<_BiIter, _Alloc, _TraitsT, __dfs_mode>::
+    _M_handle_accept(_Match_mode __match_mode, _StateIdT __i)
+    {
       if (__dfs_mode)
 	{
 	  __glibcxx_assert(!_M_has_sol);
@@ -373,7 +415,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	{
 	  if (_M_current == _M_begin
 	      && (_M_flags & regex_constants::match_not_null))
-		break;
+	    return;
 	  if (__match_mode == _Match_mode::_Prefix || _M_current == _M_end)
 	    if (!_M_has_sol)
 	      {
@@ -381,8 +423,15 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 		_M_results = _M_cur_results;
 	      }
 	}
-	  break;
-	case _S_opcode_alternative:
+    }
+
+  template<typename _BiIter, typename _Alloc, typename _TraitsT,
+	   bool __dfs_mode>
+    void _Executor<_BiIter, _Alloc, _TraitsT, __dfs_mode>::
+    _M_handle_alternative(_Match_mode __match_mode, _StateIdT __i)
+    {
+      const auto& __state = _M_nfa[__i];
+
       if (_M_nfa._M_flags & regex_constants::ECMAScript)
 	{
 	  // TODO: Fix BFS support. It is wrong.
@@ -401,7 +450,40 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	  _M_dfs(__match_mode, __state._M_next);
 	  _M_has_sol |= __has_sol;
 	}
-	  break;
+    }
+
+  template<typename _BiIter, typename _Alloc, typename _TraitsT,
+	   bool __dfs_mode>
+    void _Executor<_BiIter, _Alloc, _TraitsT, __dfs_mode>::
+    _M_dfs(_Match_mode __match_mode, _StateIdT __i)
+    {
+      if (_M_states._M_visited(__i))
+	return;
+
+      switch (_M_nfa[__i]._M_opcode())
+	{
+	case _S_opcode_repeat:
+	  _M_handle_repeat(__match_mode, __i); break;
+	case _S_opcode_subexpr_begin:
+	  _M_handle_subexpr_begin(__match_mode, __i); break;
+	case _S_opcode_subexpr_end:
+	  _M_handle_subexpr_end(__match_mode, __i); break;
+	case _S_opcode_line_begin_assertion:
+	  _M_handle_line_begin_assertion(__match_mode, __i); break;
+	case _S_opcode_line_end_assertion:
+	  _M_handle_line_end_assertion(__match_mode, __i); break;
+	case _S_opcode_word_boundary:
+	  _M_handle_word_boundary(__match_mode, __i); break;
+	case _S_opcode_subexpr_lookahead:
+	  _M_handle_subexpr_lookahead(__match_mode, __i); break;
+	case _S_opcode_match:
+	  _M_handle_match(__match_mode, __i); break;
+	case _S_opcode_backref:
+	  _M_handle_backref(__match_mode, __i); break;
+	case _S_opcode_accept:
+	  _M_handle_accept(__match_mode, __i); break;
+	case _S_opcode_alternative:
+	  _M_handle_alternative(__match_mode, __i); break;
 	default:
 	  __glibcxx_assert(false);
 	}