Skip to content

R
riscv-gcc-1
Commit e280b6ff by Tim Shen Committed by Tim Shen
Options

regex.h: Replace 8 spaces in indentation with a tab. 

2013-08-22  Tim Shen  <timshen91@gmail.com>

	* include/bits/regex.h: Replace 8 spaces in indentation with a tab.
	* include/bits/regex_automaton.h: Same.
	* include/bits/regex_automaton.tcc: Same.
	* include/bits/regex_compiler.h: Same.
	* include/bits/regex_compiler.tcc: Same.
	* include/bits/regex_constants.h: Same.
	* include/bits/regex_executor.h: Same.
	* include/bits/regex_executor.tcc: Same.

From-SVN: r201916
parent 3f97cb0b
Showing with 960 additions and 949 deletions
libstdc++-v3/ChangeLog
2013-08-22 Tim Shen <timshen91@gmail.com> 2013-08-22 Tim Shen <timshen91@gmail.com>
* include/bits/regex.h: Replace 8 spaces in indentation with a tab.
* include/bits/regex_automaton.h: Same.
* include/bits/regex_automaton.tcc: Same.
* include/bits/regex_compiler.h: Same.
* include/bits/regex_compiler.tcc: Same.
* include/bits/regex_constants.h: Same.
* include/bits/regex_executor.h: Same.
* include/bits/regex_executor.tcc: Same.
2013-08-22 Tim Shen <timshen91@gmail.com>
* include/bits/regex.h: Executor caller. * include/bits/regex.h: Executor caller.
* include/bits/regex_executor.h: Fix empty grouping problem. * include/bits/regex_executor.h: Fix empty grouping problem.
* include/bits/regex_executor.tcc: Same. * include/bits/regex_executor.tcc: Same.
......
libstdc++-v3/include/bits/regex.h
...@@ -56,71 +56,71 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION ...@@ -56,71 +56,71 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
typedef std::locale locale_type; typedef std::locale locale_type;
private: private:
struct _RegexMask struct _RegexMask
{ {
typedef typename std::ctype<char_type>::mask _BaseType; typedef typename std::ctype<char_type>::mask _BaseType;
_BaseType _M_base; _BaseType _M_base;
unsigned char _M_extended; unsigned char _M_extended;
static constexpr unsigned char _S_under = 1 << 0; static constexpr unsigned char _S_under = 1 << 0;
// FIXME: _S_blank should be removed in the future, // FIXME: _S_blank should be removed in the future,
// when locale's complete. // when locale's complete.
static constexpr unsigned char _S_blank = 1 << 1; static constexpr unsigned char _S_blank = 1 << 1;
static constexpr unsigned char _S_valid_mask = 0x3; static constexpr unsigned char _S_valid_mask = 0x3;
constexpr _RegexMask(_BaseType __base = 0, constexpr _RegexMask(_BaseType __base = 0,
unsigned char __extended = 0) unsigned char __extended = 0)
: _M_base(__base), _M_extended(__extended) : _M_base(__base), _M_extended(__extended)
{ } { }
constexpr _RegexMask constexpr _RegexMask
operator&(_RegexMask __other) const operator&(_RegexMask __other) const
{ {
return _RegexMask(_M_base & __other._M_base, return _RegexMask(_M_base & __other._M_base,
_M_extended & __other._M_extended); _M_extended & __other._M_extended);
} }
constexpr _RegexMask constexpr _RegexMask
operator|(_RegexMask __other) const operator|(_RegexMask __other) const
{ {
return _RegexMask(_M_base | __other._M_base, return _RegexMask(_M_base | __other._M_base,
_M_extended | __other._M_extended); _M_extended | __other._M_extended);
} }
constexpr _RegexMask constexpr _RegexMask
operator^(_RegexMask __other) const operator^(_RegexMask __other) const
{ {
return _RegexMask(_M_base ^ __other._M_base, return _RegexMask(_M_base ^ __other._M_base,
_M_extended ^ __other._M_extended); _M_extended ^ __other._M_extended);
} }
constexpr _RegexMask constexpr _RegexMask
operator~() const operator~() const
{ return _RegexMask(~_M_base, ~_M_extended); } { return _RegexMask(~_M_base, ~_M_extended); }
_RegexMask& _RegexMask&
operator&=(_RegexMask __other) operator&=(_RegexMask __other)
{ return *this = (*this) & __other; } { return *this = (*this) & __other; }
_RegexMask& _RegexMask&
operator|=(_RegexMask __other) operator|=(_RegexMask __other)
{ return *this = (*this) | __other; } { return *this = (*this) | __other; }
_RegexMask& _RegexMask&
operator^=(_RegexMask __other) operator^=(_RegexMask __other)
{ return *this = (*this) ^ __other; } { return *this = (*this) ^ __other; }
constexpr bool constexpr bool
operator==(_RegexMask __other) const operator==(_RegexMask __other) const
{ {
return (_M_extended & _S_valid_mask) return (_M_extended & _S_valid_mask)
== (__other._M_extended & _S_valid_mask) == (__other._M_extended & _S_valid_mask)
&& _M_base == __other._M_base; && _M_base == __other._M_base;
} }
constexpr bool constexpr bool
operator!=(_RegexMask __other) const operator!=(_RegexMask __other) const
{ return !((*this) == __other); } { return !((*this) == __other); }
}; };
public: public:
typedef _RegexMask char_class_type; typedef _RegexMask char_class_type;
...@@ -193,9 +193,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION ...@@ -193,9 +193,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
* facet. * facet.
*/ */
template<typename _Fwd_iter> template<typename _Fwd_iter>
string_type string_type
transform(_Fwd_iter __first, _Fwd_iter __last) const transform(_Fwd_iter __first, _Fwd_iter __last) const
{ {
typedef std::collate<char_type> __collate_type; typedef std::collate<char_type> __collate_type;
const __collate_type& __fclt(use_facet<__collate_type>(_M_locale)); const __collate_type& __fclt(use_facet<__collate_type>(_M_locale));
string_type __s(__first, __last); string_type __s(__first, __last);
...@@ -217,16 +217,16 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION ...@@ -217,16 +217,16 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
* @todo Implement this function. * @todo Implement this function.
*/ */
template<typename _Fwd_iter> template<typename _Fwd_iter>
string_type string_type
transform_primary(_Fwd_iter __first, _Fwd_iter __last) const transform_primary(_Fwd_iter __first, _Fwd_iter __last) const
{ {
typedef std::ctype<char_type> __ctype_type; typedef std::ctype<char_type> __ctype_type;
const __ctype_type& __fctyp(use_facet<__ctype_type>(_M_locale)); const __ctype_type& __fctyp(use_facet<__ctype_type>(_M_locale));
std::vector<char_type> __s(__first, __last); std::vector<char_type> __s(__first, __last);
// FIXME : this is not entirely correct // FIXME : this is not entirely correct
__fctyp.tolower(__s.data(), __s.data() + __s.size()); __fctyp.tolower(__s.data(), __s.data() + __s.size());
return this->transform(__s.data(), __s.data() + __s.size()); return this->transform(__s.data(), __s.data() + __s.size());
} }
/** /**
* @brief Gets a collation element by name. * @brief Gets a collation element by name.
...@@ -240,8 +240,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION ...@@ -240,8 +240,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
* character sequence is not a valid collating element. * character sequence is not a valid collating element.
*/ */
template<typename _Fwd_iter> template<typename _Fwd_iter>
string_type string_type
lookup_collatename(_Fwd_iter __first, _Fwd_iter __last) const; lookup_collatename(_Fwd_iter __first, _Fwd_iter __last) const;
/** /**
* @brief Maps one or more characters to a named character * @brief Maps one or more characters to a named character
...@@ -281,9 +281,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION ...@@ -281,9 +281,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
* - xdigit * - xdigit
*/ */
template<typename _Fwd_iter> template<typename _Fwd_iter>
char_class_type char_class_type
lookup_classname(_Fwd_iter __first, _Fwd_iter __last, lookup_classname(_Fwd_iter __first, _Fwd_iter __last,
bool __icase = false) const; bool __icase = false) const;
/** /**
* @brief Determines if @p c is a member of an identified class. * @brief Determines if @p c is a member of an identified class.
...@@ -353,182 +353,182 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION ...@@ -353,182 +353,182 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
const __ctype_type& __fctyp(use_facet<__ctype_type>(_M_locale)); const __ctype_type& __fctyp(use_facet<__ctype_type>(_M_locale));
static const char* __collatenames[] = static const char* __collatenames[] =
{ {
"NUL", "NUL",
"SOH", "SOH",
"STX", "STX",
"ETX", "ETX",
"EOT", "EOT",
"ENQ", "ENQ",
"ACK", "ACK",
"alert", "alert",
"backspace", "backspace",
"tab", "tab",
"newline", "newline",
"vertical-tab", "vertical-tab",
"form-feed", "form-feed",
"carriage-return", "carriage-return",
"SO", "SO",
"SI", "SI",
"DLE", "DLE",
"DC1", "DC1",
"DC2", "DC2",
"DC3", "DC3",
"DC4", "DC4",
"NAK", "NAK",
"SYN", "SYN",
"ETB", "ETB",
"CAN", "CAN",
"EM", "EM",
"SUB", "SUB",
"ESC", "ESC",
"IS4", "IS4",
"IS3", "IS3",
"IS2", "IS2",
"IS1", "IS1",
"space", "space",
"exclamation-mark", "exclamation-mark",
"quotation-mark", "quotation-mark",
"number-sign", "number-sign",
"dollar-sign", "dollar-sign",
"percent-sign", "percent-sign",
"ampersand", "ampersand",
"apostrophe", "apostrophe",
"left-parenthesis", "left-parenthesis",
"right-parenthesis", "right-parenthesis",
"asterisk", "asterisk",
"plus-sign", "plus-sign",
"comma", "comma",
"hyphen", "hyphen",
"period", "period",
"slash", "slash",
"zero", "zero",
"one", "one",
"two", "two",
"three", "three",
"four", "four",
"five", "five",
"six", "six",
"seven", "seven",
"eight", "eight",
"nine", "nine",
"colon", "colon",
"semicolon", "semicolon",
"less-than-sign", "less-than-sign",
"equals-sign", "equals-sign",
"greater-than-sign", "greater-than-sign",
"question-mark", "question-mark",
"commercial-at", "commercial-at",
"A", "A",
"B", "B",
"C", "C",
"D", "D",
"E", "E",
"F", "F",
"G", "G",
"H", "H",
"I", "I",
"J", "J",
"K", "K",
"L", "L",
"M", "M",
"N", "N",
"O", "O",
"P", "P",
"Q", "Q",
"R", "R",
"S", "S",
"T", "T",
"U", "U",
"V", "V",
"W", "W",
"X", "X",
"Y", "Y",
"Z", "Z",
"left-square-bracket", "left-square-bracket",
"backslash", "backslash",
"right-square-bracket", "right-square-bracket",
"circumflex", "circumflex",
"underscore", "underscore",
"grave-accent", "grave-accent",
"a", "a",
"b", "b",
"c", "c",
"d", "d",
"e", "e",
"f", "f",
"g", "g",
"h", "h",
"i", "i",
"j", "j",
"k", "k",
"l", "l",
"m", "m",
"n", "n",
"o", "o",
"p", "p",
"q", "q",
"r", "r",
"s", "s",
"t", "t",
"u", "u",
"v", "v",
"w", "w",
"x", "x",
"y", "y",
"z", "z",
"left-curly-bracket", "left-curly-bracket",
"vertical-line", "vertical-line",
"right-curly-bracket", "right-curly-bracket",
"tilde", "tilde",
"DEL", "DEL",
"" ""
}; };
// same as boost // same as boost
static const char* __digraphs[] = static const char* __digraphs[] =
{ {
"ae", "ae",
"Ae", "Ae",
"AE", "AE",
"ch", "ch",
"Ch", "Ch",
"CH", "CH",
"ll", "ll",
"Ll", "Ll",
"LL", "LL",
"ss", "ss",
"Ss", "Ss",
"SS", "SS",
"nj", "nj",
"Nj", "Nj",
"NJ", "NJ",
"dz", "dz",
"Dz", "Dz",
"DZ", "DZ",
"lj", "lj",
"Lj", "Lj",
"LJ", "LJ",
"" ""
}; };
std::string __s(__last - __first, '?'); std::string __s(__last - __first, '?');
__fctyp.narrow(__first, __last, '?', &*__s.begin()); __fctyp.narrow(__first, __last, '?', &*__s.begin());
for (unsigned int __i = 0; *__collatenames[__i]; __i++) for (unsigned int __i = 0; *__collatenames[__i]; __i++)
if (__s == __collatenames[__i]) if (__s == __collatenames[__i])
return string_type(1, __fctyp.widen((char)__i)); return string_type(1, __fctyp.widen((char)__i));
for (unsigned int __i = 0; *__digraphs[__i]; __i++) for (unsigned int __i = 0; *__digraphs[__i]; __i++)
{ {
const char* __now = __digraphs[__i]; const char* __now = __digraphs[__i];
if (__s == __now) if (__s == __now)
{ {
string_type ret(__s.size(), __fctyp.widen('?')); string_type ret(__s.size(), __fctyp.widen('?'));
__fctyp.widen(__now, __now + 2/* ouch */, &*ret.begin()); __fctyp.widen(__now, __now + 2/* ouch */, &*ret.begin());
return ret; return ret;
} }
} }
return string_type(); return string_type();
} }
...@@ -546,39 +546,39 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION ...@@ -546,39 +546,39 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
static _ClassnameEntry __classnames[] = static _ClassnameEntry __classnames[] =
{ {
{"d", ctype_base::digit}, {"d", ctype_base::digit},
{"w", {ctype_base::alnum, _RegexMask::_S_under}}, {"w", {ctype_base::alnum, _RegexMask::_S_under}},
{"s", ctype_base::space}, {"s", ctype_base::space},
{"alnum", ctype_base::alnum}, {"alnum", ctype_base::alnum},
{"alpha", ctype_base::alpha}, {"alpha", ctype_base::alpha},
{"blank", {0, _RegexMask::_S_blank}}, {"blank", {0, _RegexMask::_S_blank}},
{"cntrl", ctype_base::cntrl}, {"cntrl", ctype_base::cntrl},
{"digit", ctype_base::digit}, {"digit", ctype_base::digit},
{"graph", ctype_base::graph}, {"graph", ctype_base::graph},
{"lower", ctype_base::lower}, {"lower", ctype_base::lower},
{"print", ctype_base::print}, {"print", ctype_base::print},
{"punct", ctype_base::punct}, {"punct", ctype_base::punct},
{"space", ctype_base::space}, {"space", ctype_base::space},
{"upper", ctype_base::upper}, {"upper", ctype_base::upper},
{"xdigit", ctype_base::xdigit}, {"xdigit", ctype_base::xdigit},
}; };
std::string __s(__last - __first, '?'); std::string __s(__last - __first, '?');
__fctyp.narrow(__first, __last, '?', &__s[0]); __fctyp.narrow(__first, __last, '?', &__s[0]);
__cctyp.tolower(&*__s.begin(), &*__s.begin() + __s.size()); __cctyp.tolower(&*__s.begin(), &*__s.begin() + __s.size());
for (_ClassnameEntry* __it = __classnames; for (_ClassnameEntry* __it = __classnames;
__it < *(&__classnames + 1); __it < *(&__classnames + 1);
++__it) ++__it)
{ {
if (__s == __it->first) if (__s == __it->first)
{ {
if (__icase if (__icase
&& ((__it->second && ((__it->second
& (ctype_base::lower | ctype_base::upper)) != 0)) & (ctype_base::lower | ctype_base::upper)) != 0))
return ctype_base::alpha; return ctype_base::alpha;
return __it->second; return __it->second;
} }
} }
return 0; return 0;
} }
...@@ -591,13 +591,13 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION ...@@ -591,13 +591,13 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
const __ctype_type& __fctyp(use_facet<__ctype_type>(_M_locale)); const __ctype_type& __fctyp(use_facet<__ctype_type>(_M_locale));
return __fctyp.is(__f._M_base, __c) return __fctyp.is(__f._M_base, __c)
// [[:w:]] // [[:w:]]
|| ((__f._M_extended & _RegexMask::_S_under) || ((__f._M_extended & _RegexMask::_S_under)
&& __c == __fctyp.widen('_')) && __c == __fctyp.widen('_'))
// [[:blank:]] // [[:blank:]]
|| ((__f._M_extended & _RegexMask::_S_blank) || ((__f._M_extended & _RegexMask::_S_blank)
&& (__c == __fctyp.widen(' ') && (__c == __fctyp.widen(' ')
|| __c == __fctyp.widen('\t'))); || __c == __fctyp.widen('\t')));
} }
template<typename _Ch_type> template<typename _Ch_type>
...@@ -689,7 +689,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION ...@@ -689,7 +689,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
* @throws regex_error if @p __p is not a valid regular expression. * @throws regex_error if @p __p is not a valid regular expression.
*/ */
basic_regex(const _Ch_type* __p, basic_regex(const _Ch_type* __p,
std::size_t __len, flag_type __f = ECMAScript) std::size_t __len, flag_type __f = ECMAScript)
: basic_regex(__p, __p + __len, __f) : basic_regex(__p, __p + __len, __f)
{ } { }
...@@ -707,7 +707,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION ...@@ -707,7 +707,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
*/ */
basic_regex(const basic_regex&& __rhs) noexcept basic_regex(const basic_regex&& __rhs) noexcept
: _M_flags(__rhs._M_flags), _M_traits(__rhs._M_traits), : _M_flags(__rhs._M_flags), _M_traits(__rhs._M_traits),
_M_automaton(std::move(__rhs._M_automaton)) _M_automaton(std::move(__rhs._M_automaton))
{ } { }
/** /**
...@@ -720,12 +720,12 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION ...@@ -720,12 +720,12 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
* @throws regex_error if @p __s is not a valid regular expression. * @throws regex_error if @p __s is not a valid regular expression.
*/ */
template<typename _Ch_traits, typename _Ch_alloc> template<typename _Ch_traits, typename _Ch_alloc>
explicit explicit
basic_regex(const std::basic_string<_Ch_type, _Ch_traits, basic_regex(const std::basic_string<_Ch_type, _Ch_traits,
_Ch_alloc>& __s, _Ch_alloc>& __s,
flag_type __f = ECMAScript) flag_type __f = ECMAScript)
: basic_regex(__s.begin(), __s.end(), __f) : basic_regex(__s.begin(), __s.end(), __f)
{ } { }
/** /**
* @brief Constructs a basic regular expression from the range * @brief Constructs a basic regular expression from the range
...@@ -741,12 +741,12 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION ...@@ -741,12 +741,12 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
* expression. * expression.
*/ */
template<typename _InputIterator> template<typename _InputIterator>
basic_regex(_InputIterator __first, _InputIterator __last, basic_regex(_InputIterator __first, _InputIterator __last,
flag_type __f = ECMAScript) flag_type __f = ECMAScript)
: _M_flags(__f), : _M_flags(__f),
_M_automaton(__detail::_Compiler<_InputIterator, _Ch_type, _Rx_traits> _M_automaton(__detail::_Compiler<_InputIterator, _Ch_type, _Rx_traits>
(__first, __last, _M_traits, _M_flags)._M_get_nfa()) (__first, __last, _M_traits, _M_flags)._M_get_nfa())
{ } { }
/** /**
* @brief Constructs a basic regular expression from an initializer list. * @brief Constructs a basic regular expression from an initializer list.
...@@ -799,9 +799,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION ...@@ -799,9 +799,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
* @param __s A pointer to a string containing a regular expression. * @param __s A pointer to a string containing a regular expression.
*/ */
template<typename _Ch_typeraits, typename _Alloc> template<typename _Ch_typeraits, typename _Alloc>
basic_regex& basic_regex&
operator=(const basic_string<_Ch_type, _Ch_typeraits, _Alloc>& __s) operator=(const basic_string<_Ch_type, _Ch_typeraits, _Alloc>& __s)
{ return this->assign(__s, flags()); } { return this->assign(__s, flags()); }
// [7.8.3] assign // [7.8.3] assign
/** /**
...@@ -876,10 +876,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION ...@@ -876,10 +876,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
* regex_error is thrown, *this remains unchanged. * regex_error is thrown, *this remains unchanged.
*/ */
template<typename _Ch_typeraits, typename _Alloc> template<typename _Ch_typeraits, typename _Alloc>
basic_regex& basic_regex&
assign(const basic_string<_Ch_type, _Ch_typeraits, _Alloc>& __s, assign(const basic_string<_Ch_type, _Ch_typeraits, _Alloc>& __s,
flag_type __flags = ECMAScript) flag_type __flags = ECMAScript)
{ {
basic_regex __tmp(__s, __flags); basic_regex __tmp(__s, __flags);
this->swap(__tmp); this->swap(__tmp);
return *this; return *this;
...@@ -899,10 +899,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION ...@@ -899,10 +899,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
* regex_error is thrown, the object remains unchanged. * regex_error is thrown, the object remains unchanged.
*/ */
template<typename _InputIterator> template<typename _InputIterator>
basic_regex& basic_regex&
assign(_InputIterator __first, _InputIterator __last, assign(_InputIterator __first, _InputIterator __last,
flag_type __flags = ECMAScript) flag_type __flags = ECMAScript)
{ return this->assign(string_type(__first, __last), __flags); } { return this->assign(string_type(__first, __last), __flags); }
/** /**
* @brief Assigns a new regular expression to a regex object. * @brief Assigns a new regular expression to a regex object.
...@@ -976,31 +976,31 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION ...@@ -976,31 +976,31 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
protected: protected:
typedef std::shared_ptr<__detail::_Automaton<_Ch_type, _Rx_traits>> typedef std::shared_ptr<__detail::_Automaton<_Ch_type, _Rx_traits>>
_AutomatonPtr; _AutomatonPtr;
template<typename _BiIter, typename _Alloc, template<typename _BiIter, typename _Alloc,
typename _CharT, typename _TraitsT> typename _CharT, typename _TraitsT>
friend std::unique_ptr< friend std::unique_ptr<
__detail::_Executor<_BiIter, _Alloc, _CharT, _TraitsT>> __detail::_Executor<_BiIter, _Alloc, _CharT, _TraitsT>>
__detail::__get_executor(_BiIter, __detail::__get_executor(_BiIter,
_BiIter, _BiIter,
match_results<_BiIter, _Alloc>&, match_results<_BiIter, _Alloc>&,
const basic_regex<_CharT, _TraitsT>&, const basic_regex<_CharT, _TraitsT>&,
regex_constants::match_flag_type); regex_constants::match_flag_type);
template<typename _Bp, typename _Ap, typename _Cp, typename _Rp> template<typename _Bp, typename _Ap, typename _Cp, typename _Rp>
friend bool friend bool
regex_match(_Bp, _Bp, regex_match(_Bp, _Bp,
match_results<_Bp, _Ap>&, match_results<_Bp, _Ap>&,
const basic_regex<_Cp, _Rp>&, const basic_regex<_Cp, _Rp>&,
regex_constants::match_flag_type); regex_constants::match_flag_type);
template<typename _Bp, typename _Ap, typename _Cp, typename _Rp> template<typename _Bp, typename _Ap, typename _Cp, typename _Rp>
friend bool friend bool
regex_search(_Bp, _Bp, regex_search(_Bp, _Bp,
match_results<_Bp, _Ap>&, match_results<_Bp, _Ap>&,
const basic_regex<_Cp, _Rp>&, const basic_regex<_Cp, _Rp>&,
regex_constants::match_flag_type); regex_constants::match_flag_type);
flag_type _M_flags; flag_type _M_flags;
_Rx_traits _M_traits; _Rx_traits _M_traits;
...@@ -1220,8 +1220,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION ...@@ -1220,8 +1220,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
// Alias for sub_match'd string. // Alias for sub_match'd string.
template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc> template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc>
using __sub_match_string = basic_string< using __sub_match_string = basic_string<
typename iterator_traits<_Bi_iter>::value_type, typename iterator_traits<_Bi_iter>::value_type,
_Ch_traits, _Ch_alloc>; _Ch_traits, _Ch_alloc>;
/** /**
* @brief Tests the equivalence of a string and a regular expression * @brief Tests the equivalence of a string and a regular expression
...@@ -2019,50 +2019,50 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION ...@@ -2019,50 +2019,50 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
* @todo Implement this function. * @todo Implement this function.
*/ */
template<typename _Out_iter> template<typename _Out_iter>
_Out_iter _Out_iter
format(_Out_iter __out, const char_type* __fmt_first, format(_Out_iter __out, const char_type* __fmt_first,
const char_type* __fmt_last, const char_type* __fmt_last,
match_flag_type __flags = regex_constants::format_default) const match_flag_type __flags = regex_constants::format_default) const
{ return __out; } { return __out; }
/** /**
* @pre ready() == true * @pre ready() == true
*/ */
template<typename _Out_iter, typename _St, typename _Sa> template<typename _Out_iter, typename _St, typename _Sa>
_Out_iter _Out_iter
format(_Out_iter __out, const basic_string<char_type, _St, _Sa>& __fmt, format(_Out_iter __out, const basic_string<char_type, _St, _Sa>& __fmt,
match_flag_type __flags = regex_constants::format_default) const match_flag_type __flags = regex_constants::format_default) const
{ {
return format(__out, __fmt.data(), __fmt.data() + __fmt.size(), return format(__out, __fmt.data(), __fmt.data() + __fmt.size(),
__flags); __flags);
} }
/** /**
* @pre ready() == true * @pre ready() == true
*/ */
template<typename _Out_iter, typename _St, typename _Sa> template<typename _Out_iter, typename _St, typename _Sa>
basic_string<char_type, _St, _Sa> basic_string<char_type, _St, _Sa>
format(const basic_string<char_type, _St, _Sa>& __fmt, format(const basic_string<char_type, _St, _Sa>& __fmt,
match_flag_type __flags = regex_constants::format_default) const match_flag_type __flags = regex_constants::format_default) const
{ {
basic_string<char_type, _St, _Sa> __result; basic_string<char_type, _St, _Sa> __result;
format(std::back_inserter(__result), __fmt, __flags); format(std::back_inserter(__result), __fmt, __flags);
return __result; return __result;
} }
/** /**
* @pre ready() == true * @pre ready() == true
*/ */
string_type string_type
format(const char_type* __fmt, format(const char_type* __fmt,
match_flag_type __flags = regex_constants::format_default) const match_flag_type __flags = regex_constants::format_default) const
{ {
string_type __result; string_type __result;
format(std::back_inserter(__result), format(std::back_inserter(__result),
__fmt, __fmt,
__fmt + char_traits<char_type>::length(__fmt), __fmt + char_traits<char_type>::length(__fmt),
__flags); __flags);
return __result; return __result;
} }
//@} //@}
...@@ -2096,27 +2096,27 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION ...@@ -2096,27 +2096,27 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
private: private:
template<typename, typename, typename, typename> template<typename, typename, typename, typename>
friend class __detail::_Executor; friend class __detail::_Executor;
template<typename, typename, typename, typename> template<typename, typename, typename, typename>
friend class __detail::_DFSExecutor; friend class __detail::_DFSExecutor;
template<typename, typename, typename, typename> template<typename, typename, typename, typename>
friend class __detail::_BFSExecutor; friend class __detail::_BFSExecutor;
template<typename _Bp, typename _Ap, typename _Ch_type, typename _Rx_traits> template<typename _Bp, typename _Ap, typename _Ch_type, typename _Rx_traits>
friend bool friend bool
regex_match(_Bp, _Bp, match_results<_Bp, _Ap>&, regex_match(_Bp, _Bp, match_results<_Bp, _Ap>&,
const basic_regex<_Ch_type, const basic_regex<_Ch_type,
_Rx_traits>&, _Rx_traits>&,
regex_constants::match_flag_type); regex_constants::match_flag_type);
template<typename _Bp, typename _Ap, typename _Ch_type, typename _Rx_traits> template<typename _Bp, typename _Ap, typename _Ch_type, typename _Rx_traits>
friend bool friend bool
regex_search(_Bp, _Bp, match_results<_Bp, _Ap>&, regex_search(_Bp, _Bp, match_results<_Bp, _Ap>&,
const basic_regex<_Ch_type, const basic_regex<_Ch_type,
_Rx_traits>&, _Rx_traits>&,
regex_constants::match_flag_type); regex_constants::match_flag_type);
}; };
typedef match_results<const char*> cmatch; typedef match_results<const char*> cmatch;
...@@ -2138,17 +2138,17 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION ...@@ -2138,17 +2138,17 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
const match_results<_Bi_iter, _Alloc>& __m2) const match_results<_Bi_iter, _Alloc>& __m2)
{ {
if (__m1.ready() != __m2.ready()) if (__m1.ready() != __m2.ready())
return false; return false;
if (!__m1.ready()) // both are not ready if (!__m1.ready()) // both are not ready
return true; return true;
if (__m1.empty() != __m2.empty()) if (__m1.empty() != __m2.empty())
return false; return false;
if (__m1.empty()) // both are empty if (__m1.empty()) // both are empty
return true; return true;
return __m1.prefix() == __m2.prefix() return __m1.prefix() == __m2.prefix()
&& __m1.size() == __m2.size() && __m1.size() == __m2.size()
&& std::equal(__m1.begin(), __m1.end(), __m2.begin()) && std::equal(__m1.begin(), __m1.end(), __m2.begin())
&& __m1.suffix() == __m2.suffix(); && __m1.suffix() == __m2.suffix();
} }
/** /**
...@@ -2203,28 +2203,28 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION ...@@ -2203,28 +2203,28 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
typename _Ch_type, typename _Rx_traits> typename _Ch_type, typename _Rx_traits>
bool bool
regex_match(_Bi_iter __s, regex_match(_Bi_iter __s,
_Bi_iter __e, _Bi_iter __e,
match_results<_Bi_iter, _Alloc>& __m, match_results<_Bi_iter, _Alloc>& __m,
const basic_regex<_Ch_type, _Rx_traits>& __re, const basic_regex<_Ch_type, _Rx_traits>& __re,
regex_constants::match_flag_type __flags regex_constants::match_flag_type __flags
= regex_constants::match_default) = regex_constants::match_default)
{ {
if (__re._M_automaton == nullptr) if (__re._M_automaton == nullptr)
return false; return false;
__detail::__get_executor(__s, __e, __m, __re, __flags)->_M_match(); __detail::__get_executor(__s, __e, __m, __re, __flags)->_M_match();
if (__m.size() > 0 && __m[0].matched) if (__m.size() > 0 && __m[0].matched)
{ {
for (auto __it : __m) for (auto __it : __m)
if (!__it.matched) if (!__it.matched)
__it.first = __it.second = __e; __it.first = __it.second = __e;
__m.at(__m.size()).matched = false; __m.at(__m.size()).matched = false;
__m.at(__m.size()).first = __s; __m.at(__m.size()).first = __s;
__m.at(__m.size()).second = __s; __m.at(__m.size()).second = __s;
__m.at(__m.size()+1).matched = false; __m.at(__m.size()+1).matched = false;
__m.at(__m.size()+1).first = __e; __m.at(__m.size()+1).first = __e;
__m.at(__m.size()+1).second = __e; __m.at(__m.size()+1).second = __e;
return true; return true;
} }
return false; return false;
} }
...@@ -2364,18 +2364,18 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION ...@@ -2364,18 +2364,18 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
typename _Ch_type, typename _Rx_traits> typename _Ch_type, typename _Rx_traits>
inline bool inline bool
regex_search(_Bi_iter __first, _Bi_iter __last, regex_search(_Bi_iter __first, _Bi_iter __last,
match_results<_Bi_iter, _Alloc>& __m, match_results<_Bi_iter, _Alloc>& __m,
const basic_regex<_Ch_type, _Rx_traits>& __re, const basic_regex<_Ch_type, _Rx_traits>& __re,
regex_constants::match_flag_type __flags regex_constants::match_flag_type __flags
= regex_constants::match_default) = regex_constants::match_default)
{ {
if (__re._M_automaton == nullptr) if (__re._M_automaton == nullptr)
return false; return false;
for (auto __cur = __first; __cur != __last; ++__cur) // Any KMP-like algo? for (auto __cur = __first; __cur != __last; ++__cur) // Any KMP-like algo?
{ {
__detail::__get_executor(__cur, __last, __m, __re, __flags) __detail::__get_executor(__cur, __last, __m, __re, __flags)
->_M_search_from_first(); ->_M_search_from_first();
if (__m.size() > 0 && __m[0].matched) if (__m.size() > 0 && __m[0].matched)
{ {
for (auto __it : __m) for (auto __it : __m)
if (!__it.matched) if (!__it.matched)
...@@ -2390,7 +2390,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION ...@@ -2390,7 +2390,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
(__m.suffix().first != __m.suffix().second); (__m.suffix().first != __m.suffix().second);
return true; return true;
} }
} }
return false; return false;
} }
...@@ -2641,9 +2641,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION ...@@ -2641,9 +2641,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
regex_iterator regex_iterator
operator++(int) operator++(int)
{ {
auto __tmp = *this; auto __tmp = *this;
++(*this); ++(*this);
return __tmp; return __tmp;
} }
private: private:
...@@ -2662,11 +2662,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION ...@@ -2662,11 +2662,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
operator==(const regex_iterator& __rhs) const operator==(const regex_iterator& __rhs) const
{ {
return (_M_match.empty() && __rhs._M_match.empty()) return (_M_match.empty() && __rhs._M_match.empty())
|| (_M_begin == __rhs._M_begin || (_M_begin == __rhs._M_begin
&& _M_end == __rhs._M_end && _M_end == __rhs._M_end
&& _M_pregex == __rhs._M_pregex && _M_pregex == __rhs._M_pregex
&& _M_flags == __rhs._M_flags && _M_flags == __rhs._M_flags
&& _M_match[0] == __rhs._M_match[0]); && _M_match[0] == __rhs._M_match[0]);
} }
template<typename _Bi_iter, template<typename _Bi_iter,
...@@ -2683,27 +2683,27 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION ...@@ -2683,27 +2683,27 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
// match[i].position() shall return distance(begin, match[i].first). // match[i].position() shall return distance(begin, match[i].first).
// [28.12.1.4.5] // [28.12.1.4.5]
if (_M_match[0].matched) if (_M_match[0].matched)
{ {
auto __start = _M_match[0].second; auto __start = _M_match[0].second;
if (_M_match[0].first == _M_match[0].second) if (_M_match[0].first == _M_match[0].second)
if (__start == _M_end) if (__start == _M_end)
{ {
_M_match = value_type(); _M_match = value_type();
return *this; return *this;
} }
else else
{ {
if (regex_search(__start, _M_end, _M_match, *_M_pregex, _M_flags if (regex_search(__start, _M_end, _M_match, *_M_pregex, _M_flags
| regex_constants::match_not_null | regex_constants::match_not_null
| regex_constants::match_continuous)) | regex_constants::match_continuous))
return *this; return *this;
else else
++__start; ++__start;
} }
_M_flags |= regex_constants::match_prev_avail; _M_flags |= regex_constants::match_prev_avail;
if (!regex_search(__start, _M_end, _M_match, *_M_pregex, _M_flags)) if (!regex_search(__start, _M_end, _M_match, *_M_pregex, _M_flags))
_M_match = value_type(); _M_match = value_type();
} }
return *this; return *this;
} }
...@@ -2723,8 +2723,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION ...@@ -2723,8 +2723,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
* value of an iterator of this class is a std::sub_match object. * value of an iterator of this class is a std::sub_match object.
*/ */
template<typename _Bi_iter, template<typename _Bi_iter,
typename _Ch_type = typename iterator_traits<_Bi_iter>::value_type, typename _Ch_type = typename iterator_traits<_Bi_iter>::value_type,
typename _Rx_traits = regex_traits<_Ch_type> > typename _Rx_traits = regex_traits<_Ch_type> >
class regex_token_iterator class regex_token_iterator
{ {
public: public:
...@@ -2799,7 +2799,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION ...@@ -2799,7 +2799,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
*/ */
regex_token_iterator(_Bi_iter __a, _Bi_iter __b, regex_token_iterator(_Bi_iter __a, _Bi_iter __b,
const regex_type& __re, const regex_type& __re,
initializer_list<int> __submatches, initializer_list<int> __submatches,
regex_constants::match_flag_type __m regex_constants::match_flag_type __m
= regex_constants::match_default) = regex_constants::match_default)
: _M_position(__a, __b, __re, __m), _M_subs(__submatches), _M_n(0) : _M_position(__a, __b, __re, __m), _M_subs(__submatches), _M_n(0)
...@@ -2815,7 +2815,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION ...@@ -2815,7 +2815,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
* @param __m [IN] Policy flags for match rules. * @param __m [IN] Policy flags for match rules.
*/ */
template<std::size_t _Nm> template<std::size_t _Nm>
regex_token_iterator(_Bi_iter __a, _Bi_iter __b, regex_token_iterator(_Bi_iter __a, _Bi_iter __b,
const regex_type& __re, const regex_type& __re,
const int (&__submatches)[_Nm], const int (&__submatches)[_Nm],
regex_constants::match_flag_type __m regex_constants::match_flag_type __m
...@@ -2833,8 +2833,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION ...@@ -2833,8 +2833,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
_M_result(__rhs.result), _M_suffix(__rhs.suffix), _M_result(__rhs.result), _M_suffix(__rhs.suffix),
_M_has_m1(__rhs._M_has_m1) _M_has_m1(__rhs._M_has_m1)
{ {
if (__rhs._M_result == &__rhs._M_suffix) if (__rhs._M_result == &__rhs._M_suffix)
_M_result = &_M_suffix; _M_result = &_M_suffix;
} }
/** /**
...@@ -2883,9 +2883,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION ...@@ -2883,9 +2883,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
regex_token_iterator regex_token_iterator
operator++(int) operator++(int)
{ {
auto __tmp = *this; auto __tmp = *this;
++(*this); ++(*this);
return __tmp; return __tmp;
} }
private: private:
...@@ -2897,10 +2897,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION ...@@ -2897,10 +2897,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
const value_type& const value_type&
_M_current_match() const _M_current_match() const
{ {
if (_M_subs[_M_n] == -1) if (_M_subs[_M_n] == -1)
return (*_M_position).prefix(); return (*_M_position).prefix();
else else
return (*_M_position)[_M_subs[_M_n]]; return (*_M_position)[_M_subs[_M_n]];
} }
bool bool
...@@ -2918,8 +2918,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION ...@@ -2918,8 +2918,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
}; };
template<typename _Bi_iter, template<typename _Bi_iter,
typename _Ch_type, typename _Ch_type,
typename _Rx_traits> typename _Rx_traits>
regex_token_iterator<_Bi_iter, _Ch_type, _Rx_traits>& regex_token_iterator<_Bi_iter, _Ch_type, _Rx_traits>&
regex_token_iterator<_Bi_iter, _Ch_type, _Rx_traits>:: regex_token_iterator<_Bi_iter, _Ch_type, _Rx_traits>::
operator=(const regex_token_iterator& __rhs) operator=(const regex_token_iterator& __rhs)
...@@ -2931,88 +2931,88 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION ...@@ -2931,88 +2931,88 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
_M_suffix = __rhs._M_suffix; _M_suffix = __rhs._M_suffix;
_M_has_m1 = __rhs._M_has_m1; _M_has_m1 = __rhs._M_has_m1;
if (__rhs._M_result == &__rhs._M_suffix) if (__rhs._M_result == &__rhs._M_suffix)
_M_result = &_M_suffix; _M_result = &_M_suffix;
} }
template<typename _Bi_iter, template<typename _Bi_iter,
typename _Ch_type, typename _Ch_type,
typename _Rx_traits> typename _Rx_traits>
bool bool
regex_token_iterator<_Bi_iter, _Ch_type, _Rx_traits>:: regex_token_iterator<_Bi_iter, _Ch_type, _Rx_traits>::
operator==(const regex_token_iterator& __rhs) const operator==(const regex_token_iterator& __rhs) const
{ {
if (_M_end_of_seq() && __rhs._M_end_of_seq()) if (_M_end_of_seq() && __rhs._M_end_of_seq())
return true; return true;
if (_M_suffix.matched && __rhs._M_suffix.matched if (_M_suffix.matched && __rhs._M_suffix.matched
&& _M_suffix == __rhs._M_suffix) && _M_suffix == __rhs._M_suffix)
return true; return true;
if (_M_end_of_seq() || _M_suffix.matched if (_M_end_of_seq() || _M_suffix.matched
|| __rhs._M_end_of_seq() || __rhs._M_suffix.matched) || __rhs._M_end_of_seq() || __rhs._M_suffix.matched)
return false; return false;
return _M_position == __rhs._M_position return _M_position == __rhs._M_position
&& _M_n == __rhs._M_n && _M_n == __rhs._M_n
&& _M_subs == __rhs._M_subs; && _M_subs == __rhs._M_subs;
} }
template<typename _Bi_iter, template<typename _Bi_iter,
typename _Ch_type, typename _Ch_type,
typename _Rx_traits> typename _Rx_traits>
regex_token_iterator<_Bi_iter, _Ch_type, _Rx_traits>& regex_token_iterator<_Bi_iter, _Ch_type, _Rx_traits>&
regex_token_iterator<_Bi_iter, _Ch_type, _Rx_traits>:: regex_token_iterator<_Bi_iter, _Ch_type, _Rx_traits>::
operator++() operator++()
{ {
_Position __prev = _M_position; _Position __prev = _M_position;
if (_M_suffix.matched) if (_M_suffix.matched)
*this = regex_token_iterator(); *this = regex_token_iterator();
else if (_M_n + 1 < _M_subs.size()) else if (_M_n + 1 < _M_subs.size())
{ {
_M_n++; _M_n++;
_M_result = &_M_current_match(); _M_result = &_M_current_match();
} }
else else
{ {
_M_n = 0; _M_n = 0;
++_M_position; ++_M_position;
if (_M_position != _Position()) if (_M_position != _Position())
_M_result = &_M_current_match(); _M_result = &_M_current_match();
else if (_M_has_m1 && __prev->suffix().length() != 0) else if (_M_has_m1 && __prev->suffix().length() != 0)
{ {
_M_suffix.matched = true; _M_suffix.matched = true;
_M_suffix.first = __prev->suffix().first; _M_suffix.first = __prev->suffix().first;
_M_suffix.second = __prev->suffix().second; _M_suffix.second = __prev->suffix().second;
_M_result = &_M_suffix; _M_result = &_M_suffix;
} }
else else
*this = regex_token_iterator(); *this = regex_token_iterator();
} }
return *this; return *this;
} }
template<typename _Bi_iter, template<typename _Bi_iter,
typename _Ch_type, typename _Ch_type,
typename _Rx_traits> typename _Rx_traits>
void void
regex_token_iterator<_Bi_iter, _Ch_type, _Rx_traits>:: regex_token_iterator<_Bi_iter, _Ch_type, _Rx_traits>::
_M_init(_Bi_iter __a, _Bi_iter __b) _M_init(_Bi_iter __a, _Bi_iter __b)
{ {
_M_has_m1 = false; _M_has_m1 = false;
for (auto __it : _M_subs) for (auto __it : _M_subs)
if (__it == -1) if (__it == -1)
{ {
_M_has_m1 = true; _M_has_m1 = true;
break; break;
} }
if (_M_position != _Position()) if (_M_position != _Position())
_M_result = &_M_current_match(); _M_result = &_M_current_match();
else if (_M_has_m1) else if (_M_has_m1)
{ {
_M_suffix.matched = true; _M_suffix.matched = true;
_M_suffix.first = __a; _M_suffix.first = __a;
_M_suffix.second = __b; _M_suffix.second = __b;
_M_result = &_M_suffix; _M_result = &_M_suffix;
} }
else else
_M_result = nullptr; _M_result = nullptr;
} }
/** @brief Token iterator for C-style NULL-terminated strings. */ /** @brief Token iterator for C-style NULL-terminated strings. */
......
libstdc++-v3/include/bits/regex_automaton.h
...@@ -71,9 +71,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION ...@@ -71,9 +71,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
_StateIdT _M_next; // outgoing transition _StateIdT _M_next; // outgoing transition
union // Since they are mutual exclusive. union // Since they are mutual exclusive.
{ {
_StateIdT _M_alt; // for _S_opcode_alternative _StateIdT _M_alt; // for _S_opcode_alternative
unsigned int _M_subexpr; // for _S_opcode_subexpr_* unsigned int _M_subexpr; // for _S_opcode_subexpr_*
unsigned int _M_backref_index; // for _S_opcode_backref unsigned int _M_backref_index; // for _S_opcode_backref
}; };
_MatcherT _M_matches; // for _S_opcode_match _MatcherT _M_matches; // for _S_opcode_match
...@@ -83,17 +83,17 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION ...@@ -83,17 +83,17 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
_State(const _MatcherT& __m) _State(const _MatcherT& __m)
: _M_opcode(_S_opcode_match), _M_next(_S_invalid_state_id), : _M_opcode(_S_opcode_match), _M_next(_S_invalid_state_id),
_M_matches(__m) _M_matches(__m)
{ } { }
_State(_OpcodeT __opcode, unsigned __index) _State(_OpcodeT __opcode, unsigned __index)
: _M_opcode(__opcode), _M_next(_S_invalid_state_id) : _M_opcode(__opcode), _M_next(_S_invalid_state_id)
{ {
if (__opcode == _S_opcode_subexpr_begin if (__opcode == _S_opcode_subexpr_begin
|| __opcode == _S_opcode_subexpr_end) || __opcode == _S_opcode_subexpr_end)
_M_subexpr = __index; _M_subexpr = __index;
else if (__opcode == _S_opcode_backref) else if (__opcode == _S_opcode_backref)
_M_backref_index = __index; _M_backref_index = __index;
} }
_State(_StateIdT __next, _StateIdT __alt) _State(_StateIdT __next, _StateIdT __alt)
...@@ -162,40 +162,40 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION ...@@ -162,40 +162,40 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
_StateIdT _StateIdT
_M_insert_accept() _M_insert_accept()
{ {
this->push_back(_StateT(_S_opcode_accept)); this->push_back(_StateT(_S_opcode_accept));
_M_accepting_states.insert(this->size()-1); _M_accepting_states.insert(this->size()-1);
return this->size()-1; return this->size()-1;
} }
_StateIdT _StateIdT
_M_insert_alt(_StateIdT __next, _StateIdT __alt) _M_insert_alt(_StateIdT __next, _StateIdT __alt)
{ {
this->push_back(_StateT(__next, __alt)); this->push_back(_StateT(__next, __alt));
return this->size()-1; return this->size()-1;
} }
_StateIdT _StateIdT
_M_insert_matcher(_MatcherT __m) _M_insert_matcher(_MatcherT __m)
{ {
this->push_back(_StateT(__m)); this->push_back(_StateT(__m));
return this->size()-1; return this->size()-1;
} }
_StateIdT _StateIdT
_M_insert_subexpr_begin() _M_insert_subexpr_begin()
{ {
auto __id = _M_subexpr_count++; auto __id = _M_subexpr_count++;
_M_paren_stack.push_back(__id); _M_paren_stack.push_back(__id);
this->push_back(_StateT(_S_opcode_subexpr_begin, __id)); this->push_back(_StateT(_S_opcode_subexpr_begin, __id));
return this->size()-1; return this->size()-1;
} }
_StateIdT _StateIdT
_M_insert_subexpr_end() _M_insert_subexpr_end()
{ {
this->push_back(_StateT(_S_opcode_subexpr_end, _M_paren_stack.back())); this->push_back(_StateT(_S_opcode_subexpr_end, _M_paren_stack.back()));
_M_paren_stack.pop_back(); _M_paren_stack.pop_back();
return this->size()-1; return this->size()-1;
} }
_StateIdT _StateIdT
...@@ -225,27 +225,27 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION ...@@ -225,27 +225,27 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
public: public:
// Constructs a single-node sequence // Constructs a single-node sequence
_StateSeq(_RegexT& __ss, _StateIdT __s, _StateSeq(_RegexT& __ss, _StateIdT __s,
_StateIdT __e = _S_invalid_state_id) _StateIdT __e = _S_invalid_state_id)
: _M_nfa(__ss), _M_start(__s), _M_end1(__s), _M_end2(__e) : _M_nfa(__ss), _M_start(__s), _M_end1(__s), _M_end2(__e)
{ } { }
// Constructs a split sequence from two other sequencces // Constructs a split sequence from two other sequencces
_StateSeq(const _StateSeq& __e1, const _StateSeq& __e2) _StateSeq(const _StateSeq& __e1, const _StateSeq& __e2)
: _M_nfa(__e1._M_nfa), : _M_nfa(__e1._M_nfa),
_M_start(_M_nfa._M_insert_alt(__e1._M_start, __e2._M_start)), _M_start(_M_nfa._M_insert_alt(__e1._M_start, __e2._M_start)),
_M_end1(__e1._M_end1), _M_end2(__e2._M_end1) _M_end1(__e1._M_end1), _M_end2(__e2._M_end1)
{ } { }
// Constructs a split sequence from a single sequence // Constructs a split sequence from a single sequence
_StateSeq(const _StateSeq& __e, _StateIdT __id) _StateSeq(const _StateSeq& __e, _StateIdT __id)
: _M_nfa(__e._M_nfa), : _M_nfa(__e._M_nfa),
_M_start(_M_nfa._M_insert_alt(__id, __e._M_start)), _M_start(_M_nfa._M_insert_alt(__id, __e._M_start)),
_M_end1(__id), _M_end2(__e._M_end1) _M_end1(__id), _M_end2(__e._M_end1)
{ } { }
// Constructs a copy of a %_StateSeq // Constructs a copy of a %_StateSeq
_StateSeq(const _StateSeq& __rhs) _StateSeq(const _StateSeq& __rhs)
: _M_nfa(__rhs._M_nfa), _M_start(__rhs._M_start), : _M_nfa(__rhs._M_nfa), _M_start(__rhs._M_start),
_M_end1(__rhs._M_end1), _M_end2(__rhs._M_end2) _M_end1(__rhs._M_end1), _M_end2(__rhs._M_end2)
{ } { }
_StateSeq& operator=(const _StateSeq& __rhs); _StateSeq& operator=(const _StateSeq& __rhs);
......
libstdc++-v3/include/bits/regex_automaton.tcc
...@@ -41,27 +41,27 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION ...@@ -41,27 +41,27 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
{ {
switch (_M_opcode) switch (_M_opcode)
{ {
case _S_opcode_alternative: case _S_opcode_alternative:
ostr << "alt next=" << _M_next << " alt=" << _M_alt; ostr << "alt next=" << _M_next << " alt=" << _M_alt;
break; break;
case _S_opcode_subexpr_begin: case _S_opcode_subexpr_begin:
ostr << "subexpr begin next=" << _M_next << " index=" << _M_subexpr; ostr << "subexpr begin next=" << _M_next << " index=" << _M_subexpr;
break; break;
case _S_opcode_subexpr_end: case _S_opcode_subexpr_end:
ostr << "subexpr end next=" << _M_next << " index=" << _M_subexpr; ostr << "subexpr end next=" << _M_next << " index=" << _M_subexpr;
break; break;
case _S_opcode_backref: case _S_opcode_backref:
ostr << "backref next=" << _M_next << " index=" << _M_backref_index; ostr << "backref next=" << _M_next << " index=" << _M_backref_index;
break; break;
case _S_opcode_match: case _S_opcode_match:
ostr << "match next=" << _M_next; ostr << "match next=" << _M_next;
break; break;
case _S_opcode_accept: case _S_opcode_accept:
ostr << "accept next=" << _M_next; ostr << "accept next=" << _M_next;
break; break;
default: default:
ostr << "unknown next=" << _M_next; ostr << "unknown next=" << _M_next;
break; break;
} }
return ostr; return ostr;
} }
...@@ -73,39 +73,39 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION ...@@ -73,39 +73,39 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
{ {
switch (_M_opcode) switch (_M_opcode)
{ {
case _S_opcode_alternative: case _S_opcode_alternative:
__ostr << __id << " [label=\"" << __id << "\\nALT\"];\n" __ostr << __id << " [label=\"" << __id << "\\nALT\"];\n"
<< __id << " -> " << _M_next << __id << " -> " << _M_next
<< " [label=\"epsilon\", tailport=\"s\"];\n" << " [label=\"epsilon\", tailport=\"s\"];\n"
<< __id << " -> " << _M_alt << __id << " -> " << _M_alt
<< " [label=\"epsilon\", tailport=\"n\"];\n"; << " [label=\"epsilon\", tailport=\"n\"];\n";
break; break;
case _S_opcode_subexpr_begin: case _S_opcode_subexpr_begin:
__ostr << __id << " [label=\"" << __id << "\\nSBEGIN " __ostr << __id << " [label=\"" << __id << "\\nSBEGIN "
<< _M_subexpr << "\"];\n" << _M_subexpr << "\"];\n"
<< __id << " -> " << _M_next << " [label=\"epsilon\"];\n"; << __id << " -> " << _M_next << " [label=\"epsilon\"];\n";
break; break;
case _S_opcode_subexpr_end: case _S_opcode_subexpr_end:
__ostr << __id << " [label=\"" << __id << "\\nSEND " __ostr << __id << " [label=\"" << __id << "\\nSEND "
<< _M_subexpr << "\"];\n" << _M_subexpr << "\"];\n"
<< __id << " -> " << _M_next << " [label=\"epsilon\"];\n"; << __id << " -> " << _M_next << " [label=\"epsilon\"];\n";
break; break;
case _S_opcode_backref: case _S_opcode_backref:
__ostr << __id << " [label=\"" << __id << "\\nBACKREF " __ostr << __id << " [label=\"" << __id << "\\nBACKREF "
<< _M_subexpr << "\"];\n" << _M_subexpr << "\"];\n"
<< __id << " -> " << _M_next << " [label=\"<match>\"];\n"; << __id << " -> " << _M_next << " [label=\"<match>\"];\n";
break; break;
case _S_opcode_match: case _S_opcode_match:
__ostr << __id << " [label=\"" << __id << "\\nMATCH\"];\n" __ostr << __id << " [label=\"" << __id << "\\nMATCH\"];\n"
<< __id << " -> " << _M_next << " [label=\"<match>\"];\n"; << __id << " -> " << _M_next << " [label=\"<match>\"];\n";
break; break;
case _S_opcode_accept: case _S_opcode_accept:
__ostr << __id << " [label=\"" << __id << "\\nACC\"];\n" ; __ostr << __id << " [label=\"" << __id << "\\nACC\"];\n" ;
break; break;
default: default:
__ostr << __id << " [label=\"" << __id << "\\nUNK\"];\n" __ostr << __id << " [label=\"" << __id << "\\nUNK\"];\n"
<< __id << " -> " << _M_next << " [label=\"?\"];\n"; << __id << " -> " << _M_next << " [label=\"?\"];\n";
break; break;
} }
return __ostr; return __ostr;
} }
...@@ -135,10 +135,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION ...@@ -135,10 +135,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
// _M_paren_stack is {1, 3}, for incomplete "(a.." and "(c..". At this // _M_paren_stack is {1, 3}, for incomplete "(a.." and "(c..". At this
// time, "\\2" is valid, but "\\1" and "\\3" are not. // time, "\\2" is valid, but "\\1" and "\\3" are not.
if (__index >= _M_subexpr_count) if (__index >= _M_subexpr_count)
__throw_regex_error(regex_constants::error_backref); __throw_regex_error(regex_constants::error_backref);
for (auto __it : _M_paren_stack) for (auto __it : _M_paren_stack)
if (__index == __it) if (__index == __it)
__throw_regex_error(regex_constants::error_backref); __throw_regex_error(regex_constants::error_backref);
_M_has_backref = true; _M_has_backref = true;
this->push_back(_StateT(_S_opcode_backref, __index)); this->push_back(_StateT(_S_opcode_backref, __index));
return this->size()-1; return this->size()-1;
...@@ -159,7 +159,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION ...@@ -159,7 +159,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
_M_push_back(_StateIdT __id) _M_push_back(_StateIdT __id)
{ {
if (_M_end1 != _S_invalid_state_id) if (_M_end1 != _S_invalid_state_id)
_M_nfa[_M_end1]._M_next = __id; _M_nfa[_M_end1]._M_next = __id;
_M_end1 = __id; _M_end1 = __id;
} }
...@@ -169,14 +169,14 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION ...@@ -169,14 +169,14 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
{ {
if (_M_end2 != _S_invalid_state_id) if (_M_end2 != _S_invalid_state_id)
{ {
if (_M_end2 == _M_end1) if (_M_end2 == _M_end1)
_M_nfa[_M_end2]._M_alt = __id; _M_nfa[_M_end2]._M_alt = __id;
else else
_M_nfa[_M_end2]._M_next = __id; _M_nfa[_M_end2]._M_next = __id;
_M_end2 = _S_invalid_state_id; _M_end2 = _S_invalid_state_id;
} }
if (_M_end1 != _S_invalid_state_id) if (_M_end1 != _S_invalid_state_id)
_M_nfa[_M_end1]._M_next = __id; _M_nfa[_M_end1]._M_next = __id;
_M_end1 = __id; _M_end1 = __id;
} }
...@@ -186,16 +186,16 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION ...@@ -186,16 +186,16 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
{ {
if (_M_end2 != _S_invalid_state_id) if (_M_end2 != _S_invalid_state_id)
{ {
if (_M_end2 == _M_end1) if (_M_end2 == _M_end1)
_M_nfa[_M_end2]._M_alt = __rhs._M_start; _M_nfa[_M_end2]._M_alt = __rhs._M_start;
else else
_M_nfa[_M_end2]._M_next = __rhs._M_start; _M_nfa[_M_end2]._M_next = __rhs._M_start;
_M_end2 = _S_invalid_state_id; _M_end2 = _S_invalid_state_id;
} }
if (__rhs._M_end2 != _S_invalid_state_id) if (__rhs._M_end2 != _S_invalid_state_id)
_M_end2 = __rhs._M_end2; _M_end2 = __rhs._M_end2;
if (_M_end1 != _S_invalid_state_id) if (_M_end1 != _S_invalid_state_id)
_M_nfa[_M_end1]._M_next = __rhs._M_start; _M_nfa[_M_end1]._M_next = __rhs._M_start;
_M_end1 = __rhs._M_end1; _M_end1 = __rhs._M_end1;
} }
......
libstdc++-v3/include/bits/regex_compiler.h
...@@ -49,10 +49,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION ...@@ -49,10 +49,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
explicit explicit
_BracketMatcher(bool __is_non_matching, _BracketMatcher(bool __is_non_matching,
const _TraitsT& __t, const _TraitsT& __t,
_FlagT __flags) _FlagT __flags)
: _M_is_non_matching(__is_non_matching), _M_traits(__t), : _M_is_non_matching(__is_non_matching), _M_traits(__t),
_M_flags(__flags), _M_class_set(0) _M_flags(__flags), _M_class_set(0)
{ } { }
bool bool
...@@ -61,40 +61,40 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION ...@@ -61,40 +61,40 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
void void
_M_add_char(_CharT __c) _M_add_char(_CharT __c)
{ {
if (_M_flags & regex_constants::collate) if (_M_flags & regex_constants::collate)
if (_M_is_icase()) if (_M_is_icase())
_M_char_set.push_back(_M_traits.translate_nocase(__c)); _M_char_set.push_back(_M_traits.translate_nocase(__c));
else else
_M_char_set.push_back(_M_traits.translate(__c)); _M_char_set.push_back(_M_traits.translate(__c));
else else
_M_char_set.push_back(__c); _M_char_set.push_back(__c);
} }
void void
_M_add_collating_element(const _StringT& __s) _M_add_collating_element(const _StringT& __s)
{ {
auto __st = _M_traits.lookup_collatename(&*__s.begin(), &*__s.end()); auto __st = _M_traits.lookup_collatename(&*__s.begin(), &*__s.end());
if (__st.empty()) if (__st.empty())
__throw_regex_error(regex_constants::error_collate); __throw_regex_error(regex_constants::error_collate);
// TODO: digraph // TODO: digraph
_M_char_set.push_back(__st[0]); _M_char_set.push_back(__st[0]);
} }
void void
_M_add_equivalence_class(const _StringT& __s) _M_add_equivalence_class(const _StringT& __s)
{ {
_M_add_character_class( _M_add_character_class(
_M_traits.transform_primary(&*__s.begin(), &*__s.end())); _M_traits.transform_primary(&*__s.begin(), &*__s.end()));
} }
void void
_M_add_character_class(const _StringT& __s) _M_add_character_class(const _StringT& __s)
{ {
auto __st = _M_traits. auto __st = _M_traits.
lookup_classname(&*__s.begin(), &*__s.end(), _M_is_icase()); lookup_classname(&*__s.begin(), &*__s.end(), _M_is_icase());
if (__st == 0) if (__st == 0)
__throw_regex_error(regex_constants::error_ctype); __throw_regex_error(regex_constants::error_ctype);
_M_class_set |= __st; _M_class_set |= __st;
} }
void void
...@@ -108,11 +108,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION ...@@ -108,11 +108,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
_StringT _StringT
_M_get_str(_CharT __c) const _M_get_str(_CharT __c) const
{ {
auto __s = _StringT(1, auto __s = _StringT(1,
_M_is_icase() _M_is_icase()
? _M_traits.translate_nocase(__c) ? _M_traits.translate_nocase(__c)
: _M_traits.translate(__c)); : _M_traits.translate(__c));
return _M_traits.transform(__s.begin(), __s.end()); return _M_traits.transform(__s.begin(), __s.end());
} }
_TraitsT _M_traits; _TraitsT _M_traits;
...@@ -177,9 +177,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION ...@@ -177,9 +177,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
}; };
_Scanner(_InputIter __begin, _InputIter __end, _Scanner(_InputIter __begin, _InputIter __end,
_FlagT __flags, std::locale __loc) _FlagT __flags, std::locale __loc)
: _M_current(__begin) , _M_end(__end) , _M_flags(__flags), : _M_current(__begin) , _M_end(__end) , _M_flags(__flags),
_M_ctype(std::use_facet<_CtypeT>(__loc)), _M_state(0) _M_ctype(std::use_facet<_CtypeT>(__loc)), _M_state(0)
{ _M_advance(); } { _M_advance(); }
void void
...@@ -238,7 +238,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION ...@@ -238,7 +238,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
typedef regex_constants::syntax_option_type _FlagT; typedef regex_constants::syntax_option_type _FlagT;
_Compiler(_InputIter __b, _InputIter __e, _Compiler(_InputIter __b, _InputIter __e,
const _TraitsT& __traits, _FlagT __flags); const _TraitsT& __traits, _FlagT __flags);
std::shared_ptr<_RegexT> std::shared_ptr<_RegexT>
_M_get_nfa() const _M_get_nfa() const
......
libstdc++-v3/include/bits/regex_compiler.tcc
...@@ -98,13 +98,13 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION ...@@ -98,13 +98,13 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
} }
else if (__c == _M_ctype.widen('[')) else if (__c == _M_ctype.widen('['))
{ {
if (*++_M_current == _M_ctype.widen('^')) if (*++_M_current == _M_ctype.widen('^'))
{ {
_M_curToken = _S_token_bracket_inverse_begin; _M_curToken = _S_token_bracket_inverse_begin;
++_M_current; ++_M_current;
} }
else else
_M_curToken = _S_token_bracket_begin; _M_curToken = _S_token_bracket_begin;
_M_state |= _S_state_in_bracket; _M_state |= _S_state_in_bracket;
return; return;
} }
...@@ -223,16 +223,16 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION ...@@ -223,16 +223,16 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
} }
else if (*_M_current == _M_ctype.widen(']')) else if (*_M_current == _M_ctype.widen(']'))
{ {
_M_curToken = _S_token_bracket_end; _M_curToken = _S_token_bracket_end;
_M_state &= ~_S_state_in_bracket; _M_state &= ~_S_state_in_bracket;
++_M_current; ++_M_current;
return; return;
} }
else if (*_M_current == _M_ctype.widen('\\')) else if (*_M_current == _M_ctype.widen('\\'))
{ {
_M_eat_escape(); _M_eat_escape();
return; return;
} }
_M_curToken = _S_token_collelem_single; _M_curToken = _S_token_collelem_single;
_M_curValue.assign(1, *_M_current); _M_curValue.assign(1, *_M_current);
++_M_current; ++_M_current;
...@@ -341,23 +341,23 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION ...@@ -341,23 +341,23 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
_M_curValue.assign(1, __c); _M_curValue.assign(1, __c);
} }
else if (_M_state & _S_state_in_bracket) else if (_M_state & _S_state_in_bracket)
{ {
if (__c == _M_ctype.widen('-') if (__c == _M_ctype.widen('-')
|| __c == _M_ctype.widen('[') || __c == _M_ctype.widen('[')
|| __c == _M_ctype.widen(']')) || __c == _M_ctype.widen(']'))
{ {
_M_curToken = _S_token_ord_char; _M_curToken = _S_token_ord_char;
_M_curValue.assign(1, __c); _M_curValue.assign(1, __c);
} }
else if ((_M_flags & regex_constants::ECMAScript) else if ((_M_flags & regex_constants::ECMAScript)
&& __c == _M_ctype.widen('b')) && __c == _M_ctype.widen('b'))
{ {
_M_curToken = _S_token_ord_char; _M_curToken = _S_token_ord_char;
_M_curValue.assign(1, _M_ctype.widen(' ')); _M_curValue.assign(1, _M_ctype.widen(' '));
} }
else else
__throw_regex_error(regex_constants::error_escape); __throw_regex_error(regex_constants::error_escape);
} }
else else
__throw_regex_error(regex_constants::error_escape); __throw_regex_error(regex_constants::error_escape);
} }
...@@ -444,8 +444,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION ...@@ -444,8 +444,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
ostr << "bracket-begin\n"; ostr << "bracket-begin\n";
break; break;
case _S_token_bracket_inverse_begin: case _S_token_bracket_inverse_begin:
ostr << "bracket-inverse-begin\n"; ostr << "bracket-inverse-begin\n";
break; break;
case _S_token_bracket_end: case _S_token_bracket_end:
ostr << "bracket-end\n"; ostr << "bracket-end\n";
break; break;
...@@ -518,8 +518,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION ...@@ -518,8 +518,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
case _S_token_unknown: case _S_token_unknown:
ostr << "-- unknown token --\n"; ostr << "-- unknown token --\n";
break; break;
default: default:
_GLIBCXX_DEBUG_ASSERT(false); _GLIBCXX_DEBUG_ASSERT(false);
} }
return ostr; return ostr;
} }
...@@ -528,7 +528,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION ...@@ -528,7 +528,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
template<typename _InputIter, typename _CharT, typename _TraitsT> template<typename _InputIter, typename _CharT, typename _TraitsT>
_Compiler<_InputIter, _CharT, _TraitsT>:: _Compiler<_InputIter, _CharT, _TraitsT>::
_Compiler(_InputIter __b, _InputIter __e, _Compiler(_InputIter __b, _InputIter __e,
const _TraitsT& __traits, _FlagT __flags) const _TraitsT& __traits, _FlagT __flags)
: _M_traits(__traits), _M_scanner(__b, __e, __flags, _M_traits.getloc()), : _M_traits(__traits), _M_scanner(__b, __e, __flags, _M_traits.getloc()),
_M_state_store(__flags), _M_flags(__flags) _M_state_store(__flags), _M_flags(__flags)
{ {
...@@ -551,8 +551,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION ...@@ -551,8 +551,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
{ {
if (token == _M_scanner._M_token()) if (token == _M_scanner._M_token())
{ {
_M_cur_value = _M_scanner._M_value(); _M_cur_value = _M_scanner._M_value();
_M_scanner._M_advance(); _M_scanner._M_advance();
return true; return true;
} }
return false; return false;
...@@ -714,39 +714,39 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION ...@@ -714,39 +714,39 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
{ {
if (_M_match_token(_ScannerT::_S_token_anychar)) if (_M_match_token(_ScannerT::_S_token_anychar))
{ {
const static auto& const static auto&
__any_matcher = [](_CharT) -> bool __any_matcher = [](_CharT) -> bool
{ return true; }; { return true; };
_M_stack.push(_StateSeqT(_M_state_store, _M_stack.push(_StateSeqT(_M_state_store,
_M_state_store._M_insert_matcher _M_state_store._M_insert_matcher
(__any_matcher))); (__any_matcher)));
return true; return true;
} }
if (_M_match_token(_ScannerT::_S_token_ord_char)) if (_M_match_token(_ScannerT::_S_token_ord_char))
{ {
auto __c = _M_cur_value[0]; auto __c = _M_cur_value[0];
__detail::_Matcher<_CharT> f; __detail::_Matcher<_CharT> f;
if (_M_flags & regex_constants::icase) if (_M_flags & regex_constants::icase)
{ {
auto __traits = this->_M_traits; auto __traits = this->_M_traits;
__c = __traits.translate_nocase(__c); __c = __traits.translate_nocase(__c);
f = [__traits, __c](_CharT __ch) -> bool f = [__traits, __c](_CharT __ch) -> bool
{ return __traits.translate_nocase(__ch) == __c; }; { return __traits.translate_nocase(__ch) == __c; };
} }
else else
f = [__c](_CharT __ch) -> bool f = [__c](_CharT __ch) -> bool
{ return __ch == __c; }; { return __ch == __c; };
_M_stack.push(_StateSeqT(_M_state_store, _M_stack.push(_StateSeqT(_M_state_store,
_M_state_store._M_insert_matcher(f))); _M_state_store._M_insert_matcher(f)));
return true; return true;
} }
if (_M_match_token(_ScannerT::_S_token_backref)) if (_M_match_token(_ScannerT::_S_token_backref))
{ {
// __m.push(_Matcher::_S_opcode_ordchar, _M_cur_value); // __m.push(_Matcher::_S_opcode_ordchar, _M_cur_value);
_M_stack.push(_StateSeqT(_M_state_store, _M_state_store. _M_stack.push(_StateSeqT(_M_state_store, _M_state_store.
_M_insert_backref(_M_cur_int_value(10)))); _M_insert_backref(_M_cur_int_value(10))));
return true; return true;
} }
if (_M_match_token(_ScannerT::_S_token_subexpr_begin)) if (_M_match_token(_ScannerT::_S_token_subexpr_begin))
...@@ -776,17 +776,17 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION ...@@ -776,17 +776,17 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
_M_bracket_expression() _M_bracket_expression()
{ {
bool __inverse = bool __inverse =
_M_match_token(_ScannerT::_S_token_bracket_inverse_begin); _M_match_token(_ScannerT::_S_token_bracket_inverse_begin);
if (!(__inverse || _M_match_token(_ScannerT::_S_token_bracket_begin))) if (!(__inverse || _M_match_token(_ScannerT::_S_token_bracket_begin)))
return false; return false;
_BMatcherT __matcher( __inverse, _M_traits, _M_flags); _BMatcherT __matcher( __inverse, _M_traits, _M_flags);
// special case: only if _not_ chr first after // special case: only if _not_ chr first after
// '[' or '[^' or if ECMAscript // '[' or '[^' or if ECMAscript
if (!_M_bracket_list(__matcher) // list is empty if (!_M_bracket_list(__matcher) // list is empty
&& !(_M_flags & regex_constants::ECMAScript)) && !(_M_flags & regex_constants::ECMAScript))
__throw_regex_error(regex_constants::error_brack); __throw_regex_error(regex_constants::error_brack);
_M_stack.push(_StateSeqT(_M_state_store, _M_stack.push(_StateSeqT(_M_state_store,
_M_state_store._M_insert_matcher(__matcher))); _M_state_store._M_insert_matcher(__matcher)));
return true; return true;
} }
...@@ -796,7 +796,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION ...@@ -796,7 +796,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
_M_bracket_list(_BMatcherT& __matcher) _M_bracket_list(_BMatcherT& __matcher)
{ {
if (_M_match_token(_ScannerT::_S_token_bracket_end)) if (_M_match_token(_ScannerT::_S_token_bracket_end))
return false; return false;
_M_expression_term(__matcher); _M_expression_term(__matcher);
_M_bracket_list(__matcher); _M_bracket_list(__matcher);
return true; return true;
...@@ -823,25 +823,25 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION ...@@ -823,25 +823,25 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
return; return;
} }
if (_M_match_token(_ScannerT::_S_token_collelem_single)) // [a if (_M_match_token(_ScannerT::_S_token_collelem_single)) // [a
{ {
auto __ch = _M_cur_value[0]; auto __ch = _M_cur_value[0];
if (_M_match_token(_ScannerT::_S_token_dash)) // [a- if (_M_match_token(_ScannerT::_S_token_dash)) // [a-
{ {
// If the dash is the last character in the bracket expression, // If the dash is the last character in the bracket expression,
// it is not special. // it is not special.
if (_M_scanner._M_token() == _ScannerT::_S_token_bracket_end) if (_M_scanner._M_token() == _ScannerT::_S_token_bracket_end)
__matcher._M_add_char(_M_cur_value[0]); // [a-] <=> [a\-] __matcher._M_add_char(_M_cur_value[0]); // [a-] <=> [a\-]
else // [a-z] else // [a-z]
{ {
if (!_M_match_token(_ScannerT::_S_token_collelem_single)) if (!_M_match_token(_ScannerT::_S_token_collelem_single))
__throw_regex_error(regex_constants::error_range); __throw_regex_error(regex_constants::error_range);
__matcher._M_make_range(__ch, _M_cur_value[0]); __matcher._M_make_range(__ch, _M_cur_value[0]);
} }
} }
else // [a] else // [a]
__matcher._M_add_char(__ch); __matcher._M_add_char(__ch);
return; return;
} }
__throw_regex_error(regex_constants::error_brack); __throw_regex_error(regex_constants::error_brack);
} }
...@@ -863,32 +863,32 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION ...@@ -863,32 +863,32 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
{ {
auto __oldch = __ch; auto __oldch = __ch;
if (_M_flags & regex_constants::collate) if (_M_flags & regex_constants::collate)
if (_M_is_icase()) if (_M_is_icase())
__ch = _M_traits.translate_nocase(__ch); __ch = _M_traits.translate_nocase(__ch);
else else
__ch = _M_traits.translate(__ch); __ch = _M_traits.translate(__ch);
bool __ret = false; bool __ret = false;
for (auto __c : _M_char_set) for (auto __c : _M_char_set)
if (__c == __ch) if (__c == __ch)
{ {
__ret = true; __ret = true;
break; break;
} }
if (!__ret && _M_traits.isctype(__oldch, _M_class_set)) if (!__ret && _M_traits.isctype(__oldch, _M_class_set))
__ret = true; __ret = true;
else else
{ {
_StringT __s = _M_get_str(__ch); _StringT __s = _M_get_str(__ch);
for (auto& __it : _M_range_set) for (auto& __it : _M_range_set)
if (__it.first <= __s && __s <= __it.second) if (__it.first <= __s && __s <= __it.second)
{ {
__ret = true; __ret = true;
break; break;
} }
} }
if (_M_is_non_matching) if (_M_is_non_matching)
__ret = !__ret; __ret = !__ret;
return __ret; return __ret;
} }
......
libstdc++-v3/include/bits/regex_constants.h
...@@ -164,21 +164,21 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION ...@@ -164,21 +164,21 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
operator&(syntax_option_type __a, syntax_option_type __b) operator&(syntax_option_type __a, syntax_option_type __b)
{ {
return (syntax_option_type)(static_cast<unsigned int>(__a) return (syntax_option_type)(static_cast<unsigned int>(__a)
& static_cast<unsigned int>(__b)); & static_cast<unsigned int>(__b));
} }
constexpr inline syntax_option_type constexpr inline syntax_option_type
operator|(syntax_option_type __a, syntax_option_type __b) operator|(syntax_option_type __a, syntax_option_type __b)
{ {
return (syntax_option_type)(static_cast<unsigned int>(__a) return (syntax_option_type)(static_cast<unsigned int>(__a)
| static_cast<unsigned int>(__b)); | static_cast<unsigned int>(__b));
} }
constexpr inline syntax_option_type constexpr inline syntax_option_type
operator^(syntax_option_type __a, syntax_option_type __b) operator^(syntax_option_type __a, syntax_option_type __b)
{ {
return (syntax_option_type)(static_cast<unsigned int>(__a) return (syntax_option_type)(static_cast<unsigned int>(__a)
^ static_cast<unsigned int>(__b)); ^ static_cast<unsigned int>(__b));
} }
constexpr inline syntax_option_type constexpr inline syntax_option_type
......
libstdc++-v3/include/bits/regex_executor.h
...@@ -76,17 +76,17 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION ...@@ -76,17 +76,17 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
protected: protected:
typedef typename _NFA<_CharT, _TraitsT>::_SizeT _SizeT; typedef typename _NFA<_CharT, _TraitsT>::_SizeT _SizeT;
_Executor(_BiIter __begin, _Executor(_BiIter __begin,
_BiIter __end, _BiIter __end,
_ResultsT& __results, _ResultsT& __results,
_FlagT __flags, _FlagT __flags,
_SizeT __size) _SizeT __size)
: _M_current(__begin), _M_end(__end), _M_results(__results), : _M_current(__begin), _M_end(__end), _M_results(__results),
_M_flags(__flags) _M_flags(__flags)
{ {
__size += 2; __size += 2;
_M_results.resize(__size); _M_results.resize(__size);
for (auto __i = 0; __i < __size; __i++) for (auto __i = 0; __i < __size; __i++)
_M_results[__i].matched = false; _M_results[__i].matched = false;
} }
_BiIter _M_current; _BiIter _M_current;
...@@ -121,12 +121,12 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION ...@@ -121,12 +121,12 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
typedef regex_constants::match_flag_type _FlagT; typedef regex_constants::match_flag_type _FlagT;
_DFSExecutor(_BiIter __begin, _DFSExecutor(_BiIter __begin,
_BiIter __end, _BiIter __end,
_ResultsT& __results, _ResultsT& __results,
const _RegexT& __nfa, const _RegexT& __nfa,
_FlagT __flags) _FlagT __flags)
: _BaseT(__begin, __end, __results, __flags, __nfa._M_sub_count()), : _BaseT(__begin, __end, __results, __flags, __nfa._M_sub_count()),
_M_traits(_TraitsT()), _M_nfa(__nfa), _M_results_ret(this->_M_results) _M_traits(_TraitsT()), _M_nfa(__nfa), _M_results_ret(this->_M_results)
{ } { }
void void
...@@ -139,8 +139,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION ...@@ -139,8 +139,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
private: private:
template<bool __match_mode> template<bool __match_mode>
bool bool
_M_dfs(_StateIdT __i); _M_dfs(_StateIdT __i);
_ResultsVec _M_results_ret; _ResultsVec _M_results_ret;
_TraitsT _M_traits; _TraitsT _M_traits;
...@@ -174,17 +174,17 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION ...@@ -174,17 +174,17 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
typedef regex_constants::match_flag_type _FlagT; typedef regex_constants::match_flag_type _FlagT;
_BFSExecutor(_BiIter __begin, _BFSExecutor(_BiIter __begin,
_BiIter __end, _BiIter __end,
_ResultsT& __results, _ResultsT& __results,
const _RegexT& __nfa, const _RegexT& __nfa,
_FlagT __flags) _FlagT __flags)
: _BaseT(__begin, __end, __results, __flags, __nfa._M_sub_count()), : _BaseT(__begin, __end, __results, __flags, __nfa._M_sub_count()),
_M_nfa(__nfa) _M_nfa(__nfa)
{ {
if (_M_nfa._M_start() != _S_invalid_state_id) if (_M_nfa._M_start() != _S_invalid_state_id)
_M_covered[_M_nfa._M_start()] = _M_covered[_M_nfa._M_start()] =
_ResultsPtr(new _ResultsVec(this->_M_results)); _ResultsPtr(new _ResultsVec(this->_M_results));
_M_e_closure(); _M_e_closure();
} }
void void
...@@ -197,8 +197,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION ...@@ -197,8 +197,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
private: private:
template<bool __match_mode> template<bool __match_mode>
void void
_M_main_loop(); _M_main_loop();
void void
_M_e_closure(); _M_e_closure();
......
libstdc++-v3/include/bits/regex_executor.tcc
...@@ -41,97 +41,97 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION ...@@ -41,97 +41,97 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
_M_dfs(_StateIdT __i) _M_dfs(_StateIdT __i)
{ {
if (__i == _S_invalid_state_id) if (__i == _S_invalid_state_id)
// This is not that certain. Need deeper investigate. // This is not that certain. Need deeper investigate.
return false; return false;
auto& __current = this->_M_current; auto& __current = this->_M_current;
auto& __end = this->_M_end; auto& __end = this->_M_end;
auto& __results = _M_results_ret; auto& __results = _M_results_ret;
const auto& __state = _M_nfa[__i]; const auto& __state = _M_nfa[__i];
bool __ret = false; bool __ret = false;
switch (__state._M_opcode) switch (__state._M_opcode)
{ {
case _S_opcode_alternative: case _S_opcode_alternative:
// Greedy mode by default. For non-greedy mode, // Greedy mode by default. For non-greedy mode,
// swap _M_alt and _M_next. // swap _M_alt and _M_next.
// TODO: Add greedy mode option. // TODO: Add greedy mode option.
__ret = _M_dfs<__match_mode>(__state._M_alt) __ret = _M_dfs<__match_mode>(__state._M_alt)
|| _M_dfs<__match_mode>(__state._M_next); || _M_dfs<__match_mode>(__state._M_next);
break; break;
case _S_opcode_subexpr_begin: case _S_opcode_subexpr_begin:
// Here's the critical part: if there's nothing changed since last // Here's the critical part: if there's nothing changed since last
// visit, do NOT continue. This prevents the executor from get into // visit, do NOT continue. This prevents the executor from get into
// infinite loop when use "()*" to match "". // infinite loop when use "()*" to match "".
// //
// Every change on __results will be roll back after the recursion // Every change on __results will be roll back after the recursion
// step finished. // step finished.
if (!__results[__state._M_subexpr].matched if (!__results[__state._M_subexpr].matched
|| __results[__state._M_subexpr].first != __current) || __results[__state._M_subexpr].first != __current)
{ {
auto __back = __current; auto __back = __current;
__results[__state._M_subexpr].first = __current; __results[__state._M_subexpr].first = __current;
__ret = _M_dfs<__match_mode>(__state._M_next); __ret = _M_dfs<__match_mode>(__state._M_next);
__results[__state._M_subexpr].first = __back; __results[__state._M_subexpr].first = __back;
} }
break; break;
case _S_opcode_subexpr_end: case _S_opcode_subexpr_end:
if (__results[__state._M_subexpr].second != __current if (__results[__state._M_subexpr].second != __current
|| __results[__state._M_subexpr].matched != true) || __results[__state._M_subexpr].matched != true)
{ {
auto __back = __results[__state._M_subexpr]; auto __back = __results[__state._M_subexpr];
__results[__state._M_subexpr].second = __current; __results[__state._M_subexpr].second = __current;
__results[__state._M_subexpr].matched = true; __results[__state._M_subexpr].matched = true;
__ret = _M_dfs<__match_mode>(__state._M_next); __ret = _M_dfs<__match_mode>(__state._M_next);
__results[__state._M_subexpr] = __back; __results[__state._M_subexpr] = __back;
} }
else else
__ret = _M_dfs<__match_mode>(__state._M_next); __ret = _M_dfs<__match_mode>(__state._M_next);
break; break;
case _S_opcode_match: case _S_opcode_match:
if (__current != __end && __state._M_matches(*__current)) if (__current != __end && __state._M_matches(*__current))
{ {
++__current; ++__current;
__ret = _M_dfs<__match_mode>(__state._M_next); __ret = _M_dfs<__match_mode>(__state._M_next);
--__current; --__current;
} }
break; break;
// First fetch the matched result from __results as __submatch; // First fetch the matched result from __results as __submatch;
// then compare it with // then compare it with
// (__current, __current + (__submatch.second - __submatch.first)) // (__current, __current + (__submatch.second - __submatch.first))
// If matched, keep going; else just return to try another state. // If matched, keep going; else just return to try another state.
case _S_opcode_backref: case _S_opcode_backref:
{ {
auto& __submatch = __results[__state._M_backref_index]; auto& __submatch = __results[__state._M_backref_index];
if (!__submatch.matched) if (!__submatch.matched)
break; break;
auto __last = __current; auto __last = __current;
for (auto __tmp = __submatch.first; for (auto __tmp = __submatch.first;
__last != __end && __tmp != __submatch.second; __last != __end && __tmp != __submatch.second;
++__tmp) ++__tmp)
++__last; ++__last;
if (_M_traits.transform(__submatch.first, __submatch.second) if (_M_traits.transform(__submatch.first, __submatch.second)
== _M_traits.transform(__current, __last)) == _M_traits.transform(__current, __last))
if (__last != __current) if (__last != __current)
{ {
auto __backup = __current; auto __backup = __current;
__current = __last; __current = __last;
__ret = _M_dfs<__match_mode>(__state._M_next); __ret = _M_dfs<__match_mode>(__state._M_next);
__current = __backup; __current = __backup;
} }
else else
__ret = _M_dfs<__match_mode>(__state._M_next); __ret = _M_dfs<__match_mode>(__state._M_next);
} }
break; break;
case _S_opcode_accept: case _S_opcode_accept:
if (__match_mode) if (__match_mode)
__ret = __current == __end; __ret = __current == __end;
else else
__ret = true; __ret = true;
if (__ret) if (__ret)
this->_M_results = __results; this->_M_results = __results;
break; break;
default: default:
_GLIBCXX_DEBUG_ASSERT(false); _GLIBCXX_DEBUG_ASSERT(false);
} }
return __ret; return __ret;
} }
...@@ -142,14 +142,14 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION ...@@ -142,14 +142,14 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
_M_main_loop() _M_main_loop()
{ {
while (this->_M_current != this->_M_end) while (this->_M_current != this->_M_end)
{ {
if (!__match_mode) if (!__match_mode)
if (_M_includes_some()) if (_M_includes_some())
return; return;
_M_move(); _M_move();
++this->_M_current; ++this->_M_current;
_M_e_closure(); _M_e_closure();
} }
_M_includes_some(); _M_includes_some();
} }
...@@ -162,73 +162,73 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION ...@@ -162,73 +162,73 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
std::queue<_StateIdT> __q; std::queue<_StateIdT> __q;
std::vector<bool> __in_q(_M_nfa.size(), false); std::vector<bool> __in_q(_M_nfa.size(), false);
for (auto& __it : _M_covered) for (auto& __it : _M_covered)
{ {
__in_q[__it.first] = true; __in_q[__it.first] = true;
__q.push(__it.first); __q.push(__it.first);
} }
while (!__q.empty()) while (!__q.empty())
{ {
auto __u = __q.front(); auto __u = __q.front();
__q.pop(); __q.pop();
__in_q[__u] = false; __in_q[__u] = false;
const auto& __state = _M_nfa[__u]; const auto& __state = _M_nfa[__u];
// Can be implemented using method, but there're too much arguments. // Can be implemented using method, but there're too much arguments.
// I would use macro function before C++11, but lambda is a better // I would use macro function before C++11, but lambda is a better
// choice, since hopefully compiler can inline it. // choice, since hopefully compiler can inline it.
auto __add_visited_state = [&](_StateIdT __v) auto __add_visited_state = [&](_StateIdT __v)
{ {
if (__v == _S_invalid_state_id) if (__v == _S_invalid_state_id)
return; return;
if (_M_covered.count(__u) != 0 if (_M_covered.count(__u) != 0
&& (_M_covered.count(__v) == 0 && (_M_covered.count(__v) == 0
|| _M_match_less_than(*_M_covered[__u], *_M_covered[__v]))) || _M_match_less_than(*_M_covered[__u], *_M_covered[__v])))
{ {
_M_covered[__v] = _ResultsPtr(new _ResultsVec(*_M_covered[__u])); _M_covered[__v] = _ResultsPtr(new _ResultsVec(*_M_covered[__u]));
// if a state is updated, it's outgoing neighbors should be // if a state is updated, it's outgoing neighbors should be
// reconsidered too. Push them to the queue. // reconsidered too. Push them to the queue.
if (!__in_q[__v]) if (!__in_q[__v])
{ {
__in_q[__v] = true; __in_q[__v] = true;
__q.push(__v); __q.push(__v);
} }
} }
}; };
switch (__state._M_opcode) switch (__state._M_opcode)
{ {
case _S_opcode_alternative: case _S_opcode_alternative:
__add_visited_state(__state._M_next); __add_visited_state(__state._M_next);
__add_visited_state(__state._M_alt); __add_visited_state(__state._M_alt);
break; break;
case _S_opcode_subexpr_begin: case _S_opcode_subexpr_begin:
{ {
auto& __cu = *_M_covered[__u]; auto& __cu = *_M_covered[__u];
auto __back = __cu[__state._M_subexpr].first; auto __back = __cu[__state._M_subexpr].first;
__cu[__state._M_subexpr].first = __current; __cu[__state._M_subexpr].first = __current;
__add_visited_state(__state._M_next); __add_visited_state(__state._M_next);
__cu[__state._M_subexpr].first = __back; __cu[__state._M_subexpr].first = __back;
} }
break; break;
case _S_opcode_subexpr_end: case _S_opcode_subexpr_end:
{ {
auto& __cu = *_M_covered[__u]; auto& __cu = *_M_covered[__u];
auto __back = __cu[__state._M_subexpr]; auto __back = __cu[__state._M_subexpr];
__cu[__state._M_subexpr].second = __current; __cu[__state._M_subexpr].second = __current;
__cu[__state._M_subexpr].matched = true; __cu[__state._M_subexpr].matched = true;
__add_visited_state(__state._M_next); __add_visited_state(__state._M_next);
__cu[__state._M_subexpr] = __back; __cu[__state._M_subexpr] = __back;
} }
break; break;
case _S_opcode_match: case _S_opcode_match:
break; break;
case _S_opcode_accept: case _S_opcode_accept:
__add_visited_state(__state._M_next); __add_visited_state(__state._M_next);
break; break;
default: default:
_GLIBCXX_DEBUG_ASSERT(false); _GLIBCXX_DEBUG_ASSERT(false);
} }
} }
} }
template<typename _BiIter, typename _Alloc, template<typename _BiIter, typename _Alloc,
...@@ -238,15 +238,15 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION ...@@ -238,15 +238,15 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
{ {
decltype(_M_covered) __next; decltype(_M_covered) __next;
for (auto& __it : _M_covered) for (auto& __it : _M_covered)
{ {
const auto& __state = _M_nfa[__it.first]; const auto& __state = _M_nfa[__it.first];
if (__state._M_opcode == _S_opcode_match if (__state._M_opcode == _S_opcode_match
&& __state._M_matches(*this->_M_current)) && __state._M_matches(*this->_M_current))
if (__state._M_next != _S_invalid_state_id) if (__state._M_next != _S_invalid_state_id)
if (__next.count(__state._M_next) == 0 if (__next.count(__state._M_next) == 0
|| _M_match_less_than(*__it.second, *__next[__state._M_next])) || _M_match_less_than(*__it.second, *__next[__state._M_next]))
__next[__state._M_next] = move(__it.second); __next[__state._M_next] = move(__it.second);
} }
_M_covered = move(__next); _M_covered = move(__next);
} }
...@@ -259,21 +259,21 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION ...@@ -259,21 +259,21 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
_GLIBCXX_DEBUG_ASSERT(__u.size() == __v.size()); _GLIBCXX_DEBUG_ASSERT(__u.size() == __v.size());
auto __size = __u.size(); auto __size = __u.size();
for (auto __i = 0; __i < __size; __i++) for (auto __i = 0; __i < __size; __i++)
{ {
auto& __uit = __u[__i], __vit = __v[__i]; auto& __uit = __u[__i], __vit = __v[__i];
if (__uit.matched && !__vit.matched) if (__uit.matched && !__vit.matched)
return true; return true;
if (!__uit.matched && __vit.matched) if (!__uit.matched && __vit.matched)
return false; return false;
if (__uit.matched && __vit.matched) if (__uit.matched && __vit.matched)
{ {
// GREEDY // GREEDY
if (__uit.first != __vit.first) if (__uit.first != __vit.first)
return __uit.first < __vit.first; return __uit.first < __vit.first;
if (__uit.second != __vit.second) if (__uit.second != __vit.second)
return __uit.second > __vit.second; return __uit.second > __vit.second;
} }
} }
return false; return false;
} }
...@@ -285,22 +285,22 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION ...@@ -285,22 +285,22 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
auto& __s = _M_nfa._M_final_states(); auto& __s = _M_nfa._M_final_states();
auto& __t = _M_covered; auto& __t = _M_covered;
if (__s.size() > 0 && __t.size() > 0) if (__s.size() > 0 && __t.size() > 0)
{ {
auto __first = __s.begin(); auto __first = __s.begin();
auto __second = __t.begin(); auto __second = __t.begin();
while (__first != __s.end() && __second != __t.end()) while (__first != __s.end() && __second != __t.end())
{ {
if (*__first < __second->first) if (*__first < __second->first)
++__first; ++__first;
else if (__second->first < *__first) else if (__second->first < *__first)
++__second; ++__second;
else else
{ {
this->_M_results = *__second->second; this->_M_results = *__second->second;
return true; return true;
} }
} }
} }
return false; return false;
} }
...@@ -308,19 +308,19 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION ...@@ -308,19 +308,19 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
typename _CharT, typename _TraitsT> typename _CharT, typename _TraitsT>
std::unique_ptr<_Executor<_BiIter, _Alloc, _CharT, _TraitsT>> std::unique_ptr<_Executor<_BiIter, _Alloc, _CharT, _TraitsT>>
__get_executor(_BiIter __b, __get_executor(_BiIter __b,
_BiIter __e, _BiIter __e,
match_results<_BiIter, _Alloc>& __m, match_results<_BiIter, _Alloc>& __m,
const basic_regex<_CharT, _TraitsT>& __re, const basic_regex<_CharT, _TraitsT>& __re,
regex_constants::match_flag_type __flags) regex_constants::match_flag_type __flags)
{ {
typedef std::unique_ptr<_Executor<_BiIter, _Alloc, _CharT, _TraitsT>> typedef std::unique_ptr<_Executor<_BiIter, _Alloc, _CharT, _TraitsT>>
_ExecutorPtr; _ExecutorPtr;
typedef _DFSExecutor<_BiIter, _Alloc, _CharT, _TraitsT> _DFSExecutorT; typedef _DFSExecutor<_BiIter, _Alloc, _CharT, _TraitsT> _DFSExecutorT;
typedef _BFSExecutor<_BiIter, _Alloc, _CharT, _TraitsT> _BFSExecutorT; typedef _BFSExecutor<_BiIter, _Alloc, _CharT, _TraitsT> _BFSExecutorT;
auto __p = std::static_pointer_cast<_NFA<_CharT, _TraitsT>> auto __p = std::static_pointer_cast<_NFA<_CharT, _TraitsT>>
(__re._M_automaton); (__re._M_automaton);
if (__p->_M_has_backref) if (__p->_M_has_backref)
return _ExecutorPtr(new _DFSExecutorT(__b, __e, __m, *__p, __flags)); return _ExecutorPtr(new _DFSExecutorT(__b, __e, __m, *__p, __flags));
return _ExecutorPtr(new _BFSExecutorT(__b, __e, __m, *__p, __flags)); return _ExecutorPtr(new _BFSExecutorT(__b, __e, __m, *__p, __flags));
} }
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment