Skip to content

R
riscv-gcc-1
Commit d860c842 by Paolo Carlini Committed by Paolo Carlini
Options

regex_compiler.h: Trivial formatting / stylistic fixes. 

2010-06-27  Paolo Carlini  <paolo.carlini@oracle.com>

	* include/bits/regex_compiler.h: Trivial formatting / stylistic fixes.
	* include/bits/regex_grep_matcher.tcc: Likewise.
	* include/bits/regex_cursor.h: Likewise.
	* include/bits/regex.h: Likewise.

From-SVN: r161462
parent 83e279c4
Showing with 515 additions and 505 deletions
libstdc++-v3/ChangeLog
2010-06-27 Paolo Carlini <paolo.carlini@oracle.com>
* include/bits/regex_compiler.h: Trivial formatting / stylistic fixes.
* include/bits/regex_grep_matcher.tcc: Likewise.
* include/bits/regex_cursor.h: Likewise.
* include/bits/regex.h: Likewise.
2010-06-26 Paolo Carlini <paolo.carlini@oracle.com> 2010-06-26 Paolo Carlini <paolo.carlini@oracle.com>
* testsuite/util/testsuite_hooks.h: Cast fn to bool. * testsuite/util/testsuite_hooks.h: Cast fn to bool.
......
libstdc++-v3/include/bits/regex.h
...@@ -451,7 +451,8 @@ namespace std ...@@ -451,7 +451,8 @@ namespace std
*/ */
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, _Ch_alloc>& __s, basic_regex(const std::basic_string<_Ch_type, _Ch_traits,
_Ch_alloc>& __s,
flag_type __f = regex_constants::ECMAScript) flag_type __f = regex_constants::ECMAScript)
: _M_flags(__f), : _M_flags(__f),
_M_automaton(__regex::__compile(__s.begin(), __s.end(), _M_automaton(__regex::__compile(__s.begin(), __s.end(),
......
libstdc++-v3/include/bits/regex_compiler.h
...@@ -34,7 +34,8 @@ namespace __regex ...@@ -34,7 +34,8 @@ namespace __regex
{ {
struct _Scanner_base struct _Scanner_base
{ {
typedef unsigned int _StateT; // FIXME: replace these constanst with constexpr // FIXME: replace these constanst with constexpr
typedef unsigned int _StateT;
static const _StateT _S_state_at_start = 1 << 0; static const _StateT _S_state_at_start = 1 << 0;
static const _StateT _S_state_in_brace = 1 << 2; static const _StateT _S_state_in_brace = 1 << 2;
...@@ -153,92 +154,92 @@ namespace __regex ...@@ -153,92 +154,92 @@ namespace __regex
_M_advance() _M_advance()
{ {
if (_M_current == _M_end) if (_M_current == _M_end)
{ {
_M_curToken = _S_token_eof; _M_curToken = _S_token_eof;
return; return;
} }
_CharT __c = *_M_current; _CharT __c = *_M_current;
if (_M_state & _S_state_in_bracket) if (_M_state & _S_state_in_bracket)
{ {
_M_scan_in_bracket(); _M_scan_in_bracket();
return; return;
} }
if (_M_state & _S_state_in_brace) if (_M_state & _S_state_in_brace)
{ {
_M_scan_in_brace(); _M_scan_in_brace();
return; return;
} }
else if (_M_state & _S_state_at_start && __c == _M_ctype.widen('^')) else if (_M_state & _S_state_at_start && __c == _M_ctype.widen('^'))
{ {
_M_curToken = _S_token_line_begin; _M_curToken = _S_token_line_begin;
++_M_current; ++_M_current;
return; return;
} }
else if (__c == _M_ctype.widen('$')) else if (__c == _M_ctype.widen('$'))
{ {
_M_curToken = _S_token_line_end; _M_curToken = _S_token_line_end;
++_M_current; ++_M_current;
return; return;
} }
else if (__c == _M_ctype.widen('.')) else if (__c == _M_ctype.widen('.'))
{ {
_M_curToken = _S_token_anychar; _M_curToken = _S_token_anychar;
++_M_current; ++_M_current;
return; return;
} }
else if (__c == _M_ctype.widen('*')) else if (__c == _M_ctype.widen('*'))
{ {
_M_curToken = _S_token_closure0; _M_curToken = _S_token_closure0;
++_M_current; ++_M_current;
return; return;
} }
else if (__c == _M_ctype.widen('+')) else if (__c == _M_ctype.widen('+'))
{
_M_curToken = _S_token_closure1;
++_M_current;
return;
}
else if (__c == _M_ctype.widen('|'))
{
_M_curToken = _S_token_or;
++_M_current;
return;
}
else if (__c == _M_ctype.widen('['))
{
_M_curToken = _S_token_bracket_begin;
_M_state |= (_S_state_in_bracket | _S_state_at_start);
++_M_current;
return;
}
else if (__c == _M_ctype.widen('\\'))
{
_M_eat_escape();
return;
}
else if (!(_M_flags & (regex_constants::basic | regex_constants::grep)))
{
if (__c == _M_ctype.widen('('))
{ {
_M_curToken = _S_token_subexpr_begin; _M_curToken = _S_token_closure1;
++_M_current; ++_M_current;
return; return;
} }
else if (__c == _M_ctype.widen(')')) else if (__c == _M_ctype.widen('|'))
{ {
_M_curToken = _S_token_subexpr_end; _M_curToken = _S_token_or;
++_M_current; ++_M_current;
return; return;
} }
else if (__c == _M_ctype.widen('{')) else if (__c == _M_ctype.widen('['))
{ {
_M_curToken = _S_token_interval_begin; _M_curToken = _S_token_bracket_begin;
_M_state |= _S_state_in_brace; _M_state |= (_S_state_in_bracket | _S_state_at_start);
++_M_current; ++_M_current;
return; return;
} }
} else if (__c == _M_ctype.widen('\\'))
{
_M_eat_escape();
return;
}
else if (!(_M_flags & (regex_constants::basic | regex_constants::grep)))
{
if (__c == _M_ctype.widen('('))
{
_M_curToken = _S_token_subexpr_begin;
++_M_current;
return;
}
else if (__c == _M_ctype.widen(')'))
{
_M_curToken = _S_token_subexpr_end;
++_M_current;
return;
}
else if (__c == _M_ctype.widen('{'))
{
_M_curToken = _S_token_interval_begin;
_M_state |= _S_state_in_brace;
++_M_current;
return;
}
}
_M_curToken = _S_token_ord_char; _M_curToken = _S_token_ord_char;
_M_curValue.assign(1, __c); _M_curValue.assign(1, __c);
...@@ -252,38 +253,39 @@ namespace __regex ...@@ -252,38 +253,39 @@ namespace __regex
_M_scan_in_brace() _M_scan_in_brace()
{ {
if (_M_ctype.is(_CtypeT::digit, *_M_current)) if (_M_ctype.is(_CtypeT::digit, *_M_current))
{
_M_curToken = _S_token_dup_count;
_M_curValue.assign(1, *_M_current);
++_M_current;
while (_M_current != _M_end && _M_ctype.is(_CtypeT::digit, *_M_current))
{ {
_M_curValue += *_M_current; _M_curToken = _S_token_dup_count;
_M_curValue.assign(1, *_M_current);
++_M_current; ++_M_current;
while (_M_current != _M_end
&& _M_ctype.is(_CtypeT::digit, *_M_current))
{
_M_curValue += *_M_current;
++_M_current;
}
return;
} }
return;
}
else if (*_M_current == _M_ctype.widen(',')) else if (*_M_current == _M_ctype.widen(','))
{
_M_curToken = _S_token_comma;
++_M_current;
return;
}
if (_M_flags & (regex_constants::basic | regex_constants::grep))
{
if (*_M_current == _M_ctype.widen('\\'))
{ _M_eat_escape(); }
}
else
{
if (*_M_current == _M_ctype.widen('}'))
{ {
_M_curToken = _S_token_interval_end; _M_curToken = _S_token_comma;
_M_state &= ~_S_state_in_brace;
++_M_current; ++_M_current;
return; return;
} }
} if (_M_flags & (regex_constants::basic | regex_constants::grep))
{
if (*_M_current == _M_ctype.widen('\\'))
_M_eat_escape();
}
else
{
if (*_M_current == _M_ctype.widen('}'))
{
_M_curToken = _S_token_interval_end;
_M_state &= ~_S_state_in_brace;
++_M_current;
return;
}
}
} }
template<typename _InputIterator> template<typename _InputIterator>
...@@ -292,58 +294,58 @@ namespace __regex ...@@ -292,58 +294,58 @@ namespace __regex
_M_scan_in_bracket() _M_scan_in_bracket()
{ {
if (_M_state & _S_state_at_start && *_M_current == _M_ctype.widen('^')) if (_M_state & _S_state_at_start && *_M_current == _M_ctype.widen('^'))
{
_M_curToken = _S_token_inverse_class;
_M_state &= ~_S_state_at_start;
++_M_current;
return;
}
else if (*_M_current == _M_ctype.widen('['))
{
++_M_current;
if (_M_current == _M_end)
{
_M_curToken = _S_token_eof;
return;
}
if (*_M_current == _M_ctype.widen('.'))
{ {
_M_curToken = _S_token_collsymbol; _M_curToken = _S_token_inverse_class;
_M_eat_collsymbol(); _M_state &= ~_S_state_at_start;
++_M_current;
return; return;
} }
else if (*_M_current == _M_ctype.widen(':')) else if (*_M_current == _M_ctype.widen('['))
{ {
_M_curToken = _S_token_char_class_name; ++_M_current;
_M_eat_charclass(); if (_M_current == _M_end)
return; {
_M_curToken = _S_token_eof;
return;
}
if (*_M_current == _M_ctype.widen('.'))
{
_M_curToken = _S_token_collsymbol;
_M_eat_collsymbol();
return;
}
else if (*_M_current == _M_ctype.widen(':'))
{
_M_curToken = _S_token_char_class_name;
_M_eat_charclass();
return;
}
else if (*_M_current == _M_ctype.widen('='))
{
_M_curToken = _S_token_equiv_class_name;
_M_eat_equivclass();
return;
}
} }
else if (*_M_current == _M_ctype.widen('=')) else if (*_M_current == _M_ctype.widen('-'))
{ {
_M_curToken = _S_token_equiv_class_name; _M_curToken = _S_token_dash;
_M_eat_equivclass(); ++_M_current;
return; return;
} }
}
else if (*_M_current == _M_ctype.widen('-'))
{
_M_curToken = _S_token_dash;
++_M_current;
return;
}
else if (*_M_current == _M_ctype.widen(']')) else if (*_M_current == _M_ctype.widen(']'))
{
if (!(_M_flags & regex_constants::ECMAScript)
|| !(_M_state & _S_state_at_start))
{ {
// special case: only if _not_ chr first after '[' or '[^' and if not if (!(_M_flags & regex_constants::ECMAScript)
// ECMAscript || !(_M_state & _S_state_at_start))
_M_curToken = _S_token_bracket_end; {
++_M_current; // special case: only if _not_ chr first after
return; // '[' or '[^' and if not ECMAscript
_M_curToken = _S_token_bracket_end;
++_M_current;
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;
...@@ -356,108 +358,102 @@ namespace __regex ...@@ -356,108 +358,102 @@ namespace __regex
{ {
++_M_current; ++_M_current;
if (_M_current == _M_end) if (_M_current == _M_end)
{ {
_M_curToken = _S_token_eof; _M_curToken = _S_token_eof;
return; return;
} }
_CharT __c = *_M_current; _CharT __c = *_M_current;
++_M_current; ++_M_current;
if (__c == _M_ctype.widen('(')) if (__c == _M_ctype.widen('('))
{
if (!(_M_flags & (regex_constants::basic | regex_constants::grep)))
{ {
_M_curToken = _S_token_ord_char; if (!(_M_flags & (regex_constants::basic | regex_constants::grep)))
_M_curValue.assign(1, __c); {
} _M_curToken = _S_token_ord_char;
else _M_curValue.assign(1, __c);
{ }
_M_curToken = _S_token_subexpr_begin; else
_M_curToken = _S_token_subexpr_begin;
} }
}
else if (__c == _M_ctype.widen(')')) else if (__c == _M_ctype.widen(')'))
{
if (!(_M_flags & (regex_constants::basic | regex_constants::grep)))
{
_M_curToken = _S_token_ord_char;
_M_curValue.assign(1, __c);
}
else
{ {
_M_curToken = _S_token_subexpr_end; if (!(_M_flags & (regex_constants::basic | regex_constants::grep)))
{
_M_curToken = _S_token_ord_char;
_M_curValue.assign(1, __c);
}
else
_M_curToken = _S_token_subexpr_end;
} }
}
else if (__c == _M_ctype.widen('{')) else if (__c == _M_ctype.widen('{'))
{
if (!(_M_flags & (regex_constants::basic | regex_constants::grep)))
{ {
_M_curToken = _S_token_ord_char; if (!(_M_flags & (regex_constants::basic | regex_constants::grep)))
_M_curValue.assign(1, __c); {
} _M_curToken = _S_token_ord_char;
else _M_curValue.assign(1, __c);
{ }
_M_curToken = _S_token_interval_begin; else
_M_state |= _S_state_in_brace; {
_M_curToken = _S_token_interval_begin;
_M_state |= _S_state_in_brace;
}
} }
}
else if (__c == _M_ctype.widen('}')) else if (__c == _M_ctype.widen('}'))
{
if (!(_M_flags & (regex_constants::basic | regex_constants::grep)))
{
_M_curToken = _S_token_ord_char;
_M_curValue.assign(1, __c);
}
else
{ {
if (!(_M_state && _S_state_in_brace)) if (!(_M_flags & (regex_constants::basic | regex_constants::grep)))
__throw_regex_error(regex_constants::error_badbrace); {
_M_state &= ~_S_state_in_brace; _M_curToken = _S_token_ord_char;
_M_curToken = _S_token_interval_end; _M_curValue.assign(1, __c);
}
else
{
if (!(_M_state && _S_state_in_brace))
__throw_regex_error(regex_constants::error_badbrace);
_M_state &= ~_S_state_in_brace;
_M_curToken = _S_token_interval_end;
}
} }
}
else if (__c == _M_ctype.widen('x')) else if (__c == _M_ctype.widen('x'))
{
++_M_current;
if (_M_current == _M_end)
{ {
_M_curToken = _S_token_eof;
return;
}
if (_M_ctype.is(_CtypeT::digit, *_M_current))
{
_M_curValue.assign(1, *_M_current);
++_M_current; ++_M_current;
if (_M_current == _M_end) if (_M_current == _M_end)
{ {
_M_curToken = _S_token_eof; _M_curToken = _S_token_eof;
return; return;
} }
if (_M_ctype.is(_CtypeT::digit, *_M_current)) if (_M_ctype.is(_CtypeT::digit, *_M_current))
{ {
_M_curValue += *_M_current; _M_curValue.assign(1, *_M_current);
++_M_current; ++_M_current;
return; if (_M_current == _M_end)
} {
_M_curToken = _S_token_eof;
return;
}
if (_M_ctype.is(_CtypeT::digit, *_M_current))
{
_M_curValue += *_M_current;
++_M_current;
return;
}
}
} }
}
else if (__c == _M_ctype.widen('^') else if (__c == _M_ctype.widen('^')
|| __c == _M_ctype.widen('.') || __c == _M_ctype.widen('.')
|| __c == _M_ctype.widen('*') || __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_ctype.is(_CtypeT::digit, __c)) else if (_M_ctype.is(_CtypeT::digit, __c))
{ {
_M_curToken = _S_token_backref; _M_curToken = _S_token_backref;
_M_curValue.assign(1, __c); _M_curValue.assign(1, __c);
} }
else else
{
__throw_regex_error(regex_constants::error_escape); __throw_regex_error(regex_constants::error_escape);
}
} }
...@@ -534,89 +530,89 @@ namespace __regex ...@@ -534,89 +530,89 @@ namespace __regex
switch (_M_curToken) switch (_M_curToken)
{ {
case _S_token_anychar: case _S_token_anychar:
ostr << "any-character\n"; ostr << "any-character\n";
break; break;
case _S_token_backref: case _S_token_backref:
ostr << "backref\n"; ostr << "backref\n";
break; break;
case _S_token_bracket_begin: case _S_token_bracket_begin:
ostr << "bracket-begin\n"; ostr << "bracket-begin\n";
break; break;
case _S_token_bracket_end: case _S_token_bracket_end:
ostr << "bracket-end\n"; ostr << "bracket-end\n";
break; break;
case _S_token_char_class_name: case _S_token_char_class_name:
ostr << "char-class-name \"" << _M_curValue << "\"\n"; ostr << "char-class-name \"" << _M_curValue << "\"\n";
break; break;
case _S_token_closure0: case _S_token_closure0:
ostr << "closure0\n"; ostr << "closure0\n";
break; break;
case _S_token_closure1: case _S_token_closure1:
ostr << "closure1\n"; ostr << "closure1\n";
break; break;
case _S_token_collelem_multi: case _S_token_collelem_multi:
ostr << "coll-elem-multi \"" << _M_curValue << "\"\n"; ostr << "coll-elem-multi \"" << _M_curValue << "\"\n";
break; break;
case _S_token_collelem_single: case _S_token_collelem_single:
ostr << "coll-elem-single \"" << _M_curValue << "\"\n"; ostr << "coll-elem-single \"" << _M_curValue << "\"\n";
break; break;
case _S_token_collsymbol: case _S_token_collsymbol:
ostr << "collsymbol \"" << _M_curValue << "\"\n"; ostr << "collsymbol \"" << _M_curValue << "\"\n";
break; break;
case _S_token_comma: case _S_token_comma:
ostr << "comma\n"; ostr << "comma\n";
break; break;
case _S_token_dash: case _S_token_dash:
ostr << "dash\n"; ostr << "dash\n";
break; break;
case _S_token_dup_count: case _S_token_dup_count:
ostr << "dup count: " << _M_curValue << "\n"; ostr << "dup count: " << _M_curValue << "\n";
break; break;
case _S_token_eof: case _S_token_eof:
ostr << "EOF\n"; ostr << "EOF\n";
break; break;
case _S_token_equiv_class_name: case _S_token_equiv_class_name:
ostr << "equiv-class-name \"" << _M_curValue << "\"\n"; ostr << "equiv-class-name \"" << _M_curValue << "\"\n";
break; break;
case _S_token_interval_begin: case _S_token_interval_begin:
ostr << "interval begin\n"; ostr << "interval begin\n";
break; break;
case _S_token_interval_end: case _S_token_interval_end:
ostr << "interval end\n"; ostr << "interval end\n";
break; break;
case _S_token_line_begin: case _S_token_line_begin:
ostr << "line begin\n"; ostr << "line begin\n";
break; break;
case _S_token_line_end: case _S_token_line_end:
ostr << "line end\n"; ostr << "line end\n";
break; break;
case _S_token_opt: case _S_token_opt:
ostr << "opt\n"; ostr << "opt\n";
break; break;
case _S_token_or: case _S_token_or:
ostr << "or\n"; ostr << "or\n";
break; break;
case _S_token_ord_char: case _S_token_ord_char:
ostr << "ordinary character: \"" << _M_value() << "\"\n"; ostr << "ordinary character: \"" << _M_value() << "\"\n";
break; break;
case _S_token_quoted_char: case _S_token_quoted_char:
ostr << "quoted char\n"; ostr << "quoted char\n";
break; break;
case _S_token_subexpr_begin: case _S_token_subexpr_begin:
ostr << "subexpr begin\n"; ostr << "subexpr begin\n";
break; break;
case _S_token_subexpr_end: case _S_token_subexpr_end:
ostr << "subexpr end\n"; ostr << "subexpr end\n";
break; break;
case _S_token_word_begin: case _S_token_word_begin:
ostr << "word begin\n"; ostr << "word begin\n";
break; break;
case _S_token_word_end: case _S_token_word_end:
ostr << "word end\n"; ostr << "word end\n";
break; break;
case _S_token_unknown: case _S_token_unknown:
ostr << "-- unknown token --\n"; ostr << "-- unknown token --\n";
break; break;
} }
return ostr; return ostr;
} }
...@@ -648,7 +644,7 @@ namespace __regex ...@@ -648,7 +644,7 @@ namespace __regex
// accepts a specific token or returns false. // accepts a specific token or returns false.
bool bool
_M_match_token(_TokenT token); _M_match_token(_TokenT __token);
void void
_M_disjunction(); _M_disjunction();
...@@ -727,12 +723,12 @@ namespace __regex ...@@ -727,12 +723,12 @@ namespace __regex
bind(_Start(0), _1, _2))); bind(_Start(0), _1, _2)));
_M_disjunction(); _M_disjunction();
if (!_M_stack.empty()) if (!_M_stack.empty())
{ {
__r._M_append(_M_stack.top()); __r._M_append(_M_stack.top());
_M_stack.pop(); _M_stack.pop();
} }
__r._M_append(_M_state_store._M_insert_subexpr_end(0, __r._M_append(_M_state_store.
bind(_End(0), _1, _2))); _M_insert_subexpr_end(0, bind(_End(0), _1, _2)));
__r._M_append(_M_state_store._M_insert_accept()); __r._M_append(_M_state_store._M_insert_accept());
} }
...@@ -742,11 +738,11 @@ namespace __regex ...@@ -742,11 +738,11 @@ namespace __regex
_M_match_token(_Compiler<_InIter, _TraitsT>::_TokenT token) _M_match_token(_Compiler<_InIter, _TraitsT>::_TokenT token)
{ {
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;
} }
...@@ -757,12 +753,12 @@ namespace __regex ...@@ -757,12 +753,12 @@ namespace __regex
{ {
this->_M_alternative(); this->_M_alternative();
if (_M_match_token(_ScannerT::_S_token_or)) if (_M_match_token(_ScannerT::_S_token_or))
{ {
_StateSeq __alt1 = _M_stack.top(); _M_stack.pop(); _StateSeq __alt1 = _M_stack.top(); _M_stack.pop();
this->_M_disjunction(); this->_M_disjunction();
_StateSeq __alt2 = _M_stack.top(); _M_stack.pop(); _StateSeq __alt2 = _M_stack.top(); _M_stack.pop();
_M_stack.push(_StateSeq(__alt1, __alt2)); _M_stack.push(_StateSeq(__alt1, __alt2));
} }
} }
template<typename _InIter, typename _TraitsT> template<typename _InIter, typename _TraitsT>
...@@ -771,17 +767,17 @@ namespace __regex ...@@ -771,17 +767,17 @@ namespace __regex
_M_alternative() _M_alternative()
{ {
if (this->_M_term()) if (this->_M_term())
{
_StateSeq __re = _M_stack.top(); _M_stack.pop();
this->_M_alternative();
if (!_M_stack.empty())
{ {
__re._M_append(_M_stack.top()); _StateSeq __re = _M_stack.top(); _M_stack.pop();
_M_stack.pop(); this->_M_alternative();
if (!_M_stack.empty())
{
__re._M_append(_M_stack.top());
_M_stack.pop();
}
_M_stack.push(__re);
return true;
} }
_M_stack.push(__re);
return true;
}
return false; return false;
} }
...@@ -793,10 +789,10 @@ namespace __regex ...@@ -793,10 +789,10 @@ namespace __regex
if (this->_M_assertion()) if (this->_M_assertion())
return true; return true;
if (this->_M_atom()) if (this->_M_atom())
{ {
this->_M_quantifier(); this->_M_quantifier();
return true; return true;
} }
return false; return false;
} }
...@@ -806,25 +802,25 @@ namespace __regex ...@@ -806,25 +802,25 @@ namespace __regex
_M_assertion() _M_assertion()
{ {
if (_M_match_token(_ScannerT::_S_token_line_begin)) if (_M_match_token(_ScannerT::_S_token_line_begin))
{ {
// __m.push(_Matcher::_S_opcode_line_begin); // __m.push(_Matcher::_S_opcode_line_begin);
return true; return true;
} }
if (_M_match_token(_ScannerT::_S_token_line_end)) if (_M_match_token(_ScannerT::_S_token_line_end))
{ {
// __m.push(_Matcher::_S_opcode_line_end); // __m.push(_Matcher::_S_opcode_line_end);
return true; return true;
} }
if (_M_match_token(_ScannerT::_S_token_word_begin)) if (_M_match_token(_ScannerT::_S_token_word_begin))
{ {
// __m.push(_Matcher::_S_opcode_word_begin); // __m.push(_Matcher::_S_opcode_word_begin);
return true; return true;
} }
if (_M_match_token(_ScannerT::_S_token_word_end)) if (_M_match_token(_ScannerT::_S_token_word_end))
{ {
// __m.push(_Matcher::_S_opcode_word_end); // __m.push(_Matcher::_S_opcode_word_end);
return true; return true;
} }
return false; return false;
} }
...@@ -834,69 +830,71 @@ namespace __regex ...@@ -834,69 +830,71 @@ namespace __regex
_M_quantifier() _M_quantifier()
{ {
if (_M_match_token(_ScannerT::_S_token_closure0)) if (_M_match_token(_ScannerT::_S_token_closure0))
{ {
if (_M_stack.empty()) if (_M_stack.empty())
__throw_regex_error(regex_constants::error_badrepeat); __throw_regex_error(regex_constants::error_badrepeat);
_StateSeq __r(_M_stack.top(), -1); _StateSeq __r(_M_stack.top(), -1);
__r._M_append(__r._M_front()); __r._M_append(__r._M_front());
_M_stack.pop(); _M_stack.pop();
_M_stack.push(__r); _M_stack.push(__r);
return true; return true;
} }
if (_M_match_token(_ScannerT::_S_token_closure1)) if (_M_match_token(_ScannerT::_S_token_closure1))
{ {
if (_M_stack.empty()) if (_M_stack.empty())
__throw_regex_error(regex_constants::error_badrepeat); __throw_regex_error(regex_constants::error_badrepeat);
_StateSeq __r(_M_state_store, _StateSeq __r(_M_state_store,
_M_state_store._M_insert_alt(_S_invalid_state_id, _M_state_store.
_M_stack.top()._M_front())); _M_insert_alt(_S_invalid_state_id,
_M_stack.top()._M_append(__r); _M_stack.top()._M_front()));
return true; _M_stack.top()._M_append(__r);
} return true;
}
if (_M_match_token(_ScannerT::_S_token_opt)) if (_M_match_token(_ScannerT::_S_token_opt))
{ {
if (_M_stack.empty()) if (_M_stack.empty())
__throw_regex_error(regex_constants::error_badrepeat); __throw_regex_error(regex_constants::error_badrepeat);
_StateSeq __r(_M_stack.top(), -1); _StateSeq __r(_M_stack.top(), -1);
_M_stack.pop(); _M_stack.pop();
_M_stack.push(__r); _M_stack.push(__r);
return true; return true;
} }
if (_M_match_token(_ScannerT::_S_token_interval_begin)) if (_M_match_token(_ScannerT::_S_token_interval_begin))
{ {
if (_M_stack.empty()) if (_M_stack.empty())
__throw_regex_error(regex_constants::error_badrepeat); __throw_regex_error(regex_constants::error_badrepeat);
if (!_M_match_token(_ScannerT::_S_token_dup_count)) if (!_M_match_token(_ScannerT::_S_token_dup_count))
__throw_regex_error(regex_constants::error_badbrace); __throw_regex_error(regex_constants::error_badbrace);
_StateSeq __r(_M_stack.top()); _StateSeq __r(_M_stack.top());
int __min_rep = _M_cur_int_value(10); int __min_rep = _M_cur_int_value(10);
for (int __i = 1; __i < __min_rep; ++__i) for (int __i = 1; __i < __min_rep; ++__i)
_M_stack.top()._M_append(__r._M_clone()); _M_stack.top()._M_append(__r._M_clone());
if (_M_match_token(_ScannerT::_S_token_comma)) if (_M_match_token(_ScannerT::_S_token_comma))
if (_M_match_token(_ScannerT::_S_token_dup_count)) if (_M_match_token(_ScannerT::_S_token_dup_count))
{ {
int __n = _M_cur_int_value(10) - __min_rep; int __n = _M_cur_int_value(10) - __min_rep;
if (__n < 0) if (__n < 0)
__throw_regex_error(regex_constants::error_badbrace); __throw_regex_error(regex_constants::error_badbrace);
for (int __i = 0; __i < __n; ++__i) for (int __i = 0; __i < __n; ++__i)
{ {
_StateSeq __r(_M_state_store, _StateSeq __r(_M_state_store,
_M_state_store._M_insert_alt(_S_invalid_state_id, _M_state_store.
_M_stack.top()._M_front())); _M_insert_alt(_S_invalid_state_id,
_M_stack.top()._M_append(__r); _M_stack.top()._M_front()));
} _M_stack.top()._M_append(__r);
} }
else }
{ else
_StateSeq __r(_M_stack.top(), -1); {
__r._M_push_back(__r._M_front()); _StateSeq __r(_M_stack.top(), -1);
_M_stack.pop(); __r._M_push_back(__r._M_front());
_M_stack.push(__r); _M_stack.pop();
} _M_stack.push(__r);
if (!_M_match_token(_ScannerT::_S_token_interval_end)) }
__throw_regex_error(regex_constants::error_brace); if (!_M_match_token(_ScannerT::_S_token_interval_end))
return true; __throw_regex_error(regex_constants::error_brace);
} return true;
}
return false; return false;
} }
...@@ -913,49 +911,54 @@ namespace __regex ...@@ -913,49 +911,54 @@ namespace __regex
typedef _EndTagger<_InIter, _TraitsT> _End; typedef _EndTagger<_InIter, _TraitsT> _End;
if (_M_match_token(_ScannerT::_S_token_anychar)) if (_M_match_token(_ScannerT::_S_token_anychar))
{ {
_M_stack.push(_StateSeq(_M_state_store, _M_stack.push(_StateSeq(_M_state_store,
_M_state_store._M_insert_matcher(bind(_AnyMatcher, _1)))); _M_state_store.
return true; _M_insert_matcher(bind(_AnyMatcher, _1))));
} return true;
}
if (_M_match_token(_ScannerT::_S_token_ord_char)) if (_M_match_token(_ScannerT::_S_token_ord_char))
{ {
_M_stack.push(_StateSeq(_M_state_store, _M_stack.push(_StateSeq
_M_state_store._M_insert_matcher( (_M_state_store, _M_state_store.
bind(_CMatcher(_M_cur_value[0], _M_traits), _1)))); _M_insert_matcher
return true; (bind(_CMatcher(_M_cur_value[0], _M_traits), _1))));
} return true;
}
if (_M_match_token(_ScannerT::_S_token_quoted_char)) if (_M_match_token(_ScannerT::_S_token_quoted_char))
{ {
// note that in the ECMA grammar, this case covers backrefs. // note that in the ECMA grammar, this case covers backrefs.
_M_stack.push(_StateSeq(_M_state_store, _M_stack.push(_StateSeq(_M_state_store,
_M_state_store._M_insert_matcher( _M_state_store.
bind(_CMatcher(_M_cur_value[0], _M_traits), _1)))); _M_insert_matcher
return true; (bind(_CMatcher(_M_cur_value[0], _M_traits),
} _1))));
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);
return true; return true;
} }
if (_M_match_token(_ScannerT::_S_token_subexpr_begin)) if (_M_match_token(_ScannerT::_S_token_subexpr_begin))
{
int __mark = _M_state_store._M_sub_count();
_StateSeq __r(_M_state_store,
_M_state_store._M_insert_subexpr_begin(bind(_Start(__mark), _1, _2)));
this->_M_disjunction();
if (!_M_match_token(_ScannerT::_S_token_subexpr_end))
__throw_regex_error(regex_constants::error_paren);
if (!_M_stack.empty())
{ {
__r._M_append(_M_stack.top()); int __mark = _M_state_store._M_sub_count();
_M_stack.pop(); _StateSeq __r(_M_state_store,
_M_state_store.
_M_insert_subexpr_begin(bind(_Start(__mark), _1, _2)));
this->_M_disjunction();
if (!_M_match_token(_ScannerT::_S_token_subexpr_end))
__throw_regex_error(regex_constants::error_paren);
if (!_M_stack.empty())
{
__r._M_append(_M_stack.top());
_M_stack.pop();
}
__r._M_append(_M_state_store._M_insert_subexpr_end
(__mark, bind(_End(__mark), _1, _2)));
_M_stack.push(__r);
return true;
} }
__r._M_append(_M_state_store._M_insert_subexpr_end(__mark,
bind(_End(__mark), _1, _2)));
_M_stack.push(__r);
return true;
}
return _M_bracket_expression(); return _M_bracket_expression();
} }
...@@ -967,17 +970,17 @@ namespace __regex ...@@ -967,17 +970,17 @@ namespace __regex
using std::bind; using std::bind;
using std::placeholders::_1; using std::placeholders::_1;
if (_M_match_token(_ScannerT::_S_token_bracket_begin)) if (_M_match_token(_ScannerT::_S_token_bracket_begin))
{ {
_RMatcherT __matcher(_M_match_token(_ScannerT::_S_token_line_begin), _RMatcherT __matcher(_M_match_token(_ScannerT::_S_token_line_begin),
_M_traits); _M_traits);
if (!_M_bracket_list(__matcher) if (!_M_bracket_list(__matcher)
|| !_M_match_token(_ScannerT::_S_token_bracket_end)) || !_M_match_token(_ScannerT::_S_token_bracket_end))
__throw_regex_error(regex_constants::error_brack); __throw_regex_error(regex_constants::error_brack);
_M_stack.push(_StateSeq(_M_state_store, _M_stack.push(_StateSeq(_M_state_store,
_M_state_store._M_insert_matcher( _M_state_store._M_insert_matcher
bind(__matcher, _1)))); (bind(__matcher, _1))));
return true; return true;
} }
return false; return false;
} }
...@@ -989,11 +992,11 @@ namespace __regex ...@@ -989,11 +992,11 @@ namespace __regex
_M_bracket_list(_RMatcherT& __matcher) _M_bracket_list(_RMatcherT& __matcher)
{ {
if (_M_follow_list(__matcher)) if (_M_follow_list(__matcher))
{ {
if (_M_match_token(_ScannerT::_S_token_dash)) if (_M_match_token(_ScannerT::_S_token_dash))
__matcher._M_add_char(_M_cur_value[0]); __matcher._M_add_char(_M_cur_value[0]);
return true; return true;
} }
return false; return false;
} }
...@@ -1018,10 +1021,11 @@ namespace __regex ...@@ -1018,10 +1021,11 @@ namespace __regex
_Compiler<_InIter, _TraitsT>:: _Compiler<_InIter, _TraitsT>::
_M_expression_term(_RMatcherT& __matcher) _M_expression_term(_RMatcherT& __matcher)
{ {
return _M_collating_symbol(__matcher) return (_M_collating_symbol(__matcher)
|| _M_character_class(__matcher) || _M_character_class(__matcher)
|| _M_equivalence_class(__matcher) || _M_equivalence_class(__matcher)
|| (_M_start_range(__matcher) && _M_range_expression(__matcher)); || (_M_start_range(__matcher)
&& _M_range_expression(__matcher)));
} }
template<typename _InIter, typename _TraitsT> template<typename _InIter, typename _TraitsT>
...@@ -1048,15 +1052,15 @@ namespace __regex ...@@ -1048,15 +1052,15 @@ namespace __regex
_M_collating_symbol(_RMatcherT& __matcher) _M_collating_symbol(_RMatcherT& __matcher)
{ {
if (_M_match_token(_ScannerT::_S_token_collelem_single)) if (_M_match_token(_ScannerT::_S_token_collelem_single))
{ {
__matcher._M_add_char(_M_cur_value[0]); __matcher._M_add_char(_M_cur_value[0]);
return true; return true;
} }
if (_M_match_token(_ScannerT::_S_token_collsymbol)) if (_M_match_token(_ScannerT::_S_token_collsymbol))
{ {
__matcher._M_add_collating_element(_M_cur_value); __matcher._M_add_collating_element(_M_cur_value);
return true; return true;
} }
return false; return false;
} }
...@@ -1066,10 +1070,10 @@ namespace __regex ...@@ -1066,10 +1070,10 @@ namespace __regex
_M_equivalence_class(_RMatcherT& __matcher) _M_equivalence_class(_RMatcherT& __matcher)
{ {
if (_M_match_token(_ScannerT::_S_token_equiv_class_name)) if (_M_match_token(_ScannerT::_S_token_equiv_class_name))
{ {
__matcher._M_add_equivalence_class(_M_cur_value); __matcher._M_add_equivalence_class(_M_cur_value);
return true; return true;
} }
return false; return false;
} }
...@@ -1079,10 +1083,10 @@ namespace __regex ...@@ -1079,10 +1083,10 @@ namespace __regex
_M_character_class(_RMatcherT& __matcher) _M_character_class(_RMatcherT& __matcher)
{ {
if (_M_match_token(_ScannerT::_S_token_char_class_name)) if (_M_match_token(_ScannerT::_S_token_char_class_name))
{ {
__matcher._M_add_character_class(_M_cur_value); __matcher._M_add_character_class(_M_cur_value);
return true; return true;
} }
return false; return false;
} }
......
libstdc++-v3/include/bits/regex_cursor.h
...@@ -64,11 +64,11 @@ namespace __regex ...@@ -64,11 +64,11 @@ namespace __regex
const _FwdIterT& const _FwdIterT&
_M_begin() const _M_begin() const
{ return _M_b; } { return _M_b; }
const _FwdIterT& const _FwdIterT&
_M_end() const _M_end() const
{ return _M_e; } { return _M_e; }
bool bool
_M_at_end() const _M_at_end() const
...@@ -82,9 +82,9 @@ namespace __regex ...@@ -82,9 +82,9 @@ namespace __regex
// Helper funxtion to create a cursor specialized for an iterator class. // Helper funxtion to create a cursor specialized for an iterator class.
template<typename _FwdIterT> template<typename _FwdIterT>
_SpecializedCursor<_FwdIterT> inline _SpecializedCursor<_FwdIterT>
__cursor(const _FwdIterT& __b, const _FwdIterT __e) __cursor(const _FwdIterT& __b, const _FwdIterT __e)
{ return _SpecializedCursor<_FwdIterT>(__b, __e); } { return _SpecializedCursor<_FwdIterT>(__b, __e); }
} // namespace __regex } // namespace __regex
} // namespace std } // namespace std
......
libstdc++-v3/include/bits/regex_grep_matcher.tcc
...@@ -34,10 +34,9 @@ namespace ...@@ -34,10 +34,9 @@ namespace
{ {
// A stack of states used in evaluating the NFA. // A stack of states used in evaluating the NFA.
typedef std::stack< typedef std::stack<std::__regex::_StateIdT,
std::__regex::_StateIdT,
std::vector<std::__regex::_StateIdT> std::vector<std::__regex::_StateIdT>
> _StateStack; > _StateStack;
// Obtains the next state set given the current state set __s and the current // Obtains the next state set given the current state set __s and the current
// input character. // input character.
...@@ -48,16 +47,16 @@ namespace ...@@ -48,16 +47,16 @@ namespace
{ {
std::__regex::_StateSet __m; std::__regex::_StateSet __m;
for (std::__regex::_StateSet::const_iterator __i = __s.begin(); for (std::__regex::_StateSet::const_iterator __i = __s.begin();
__i != __s.end(); ++__i) __i != __s.end(); ++__i)
{ {
if (*__i == std::__regex::_S_invalid_state_id) if (*__i == std::__regex::_S_invalid_state_id)
continue; continue;
const std::__regex::_State& __state = __nfa[*__i]; const std::__regex::_State& __state = __nfa[*__i];
if (__state._M_opcode == std::__regex::_S_opcode_match if (__state._M_opcode == std::__regex::_S_opcode_match
&& __state._M_matches(__p)) && __state._M_matches(__p))
__m.insert(__state._M_next); __m.insert(__state._M_next);
} }
return __m; return __m;
} }
...@@ -67,19 +66,19 @@ namespace ...@@ -67,19 +66,19 @@ namespace
const std::__regex::_StateSet& __t) const std::__regex::_StateSet& __t)
{ {
if (__s.size() > 0 && __t.size() > 0) if (__s.size() > 0 && __t.size() > 0)
{
std::__regex::_StateSet::const_iterator __first = __s.begin();
std::__regex::_StateSet::const_iterator __second = __t.begin();
while (__first != __s.end() && __second != __t.end())
{ {
if (*__first < *__second) std::__regex::_StateSet::const_iterator __first = __s.begin();
++__first; std::__regex::_StateSet::const_iterator __second = __t.begin();
else if (*__second < *__first) while (__first != __s.end() && __second != __t.end())
++__second; {
else if (*__first < *__second)
return true; ++__first;
else if (*__second < *__first)
++__second;
else
return true;
}
} }
}
return false; return false;
} }
...@@ -91,10 +90,10 @@ namespace ...@@ -91,10 +90,10 @@ namespace
std::__regex::_StateSet& __e) std::__regex::_StateSet& __e)
{ {
if (__e.count(__u) == 0) if (__e.count(__u) == 0)
{ {
__e.insert(__u); __e.insert(__u);
__s.push(__u); __s.push(__u);
} }
} }
} // anonymous namespace } // anonymous namespace
...@@ -102,9 +101,8 @@ namespace ...@@ -102,9 +101,8 @@ namespace
namespace __regex namespace __regex
{ {
inline _Grep_matcher:: inline _Grep_matcher::
_Grep_matcher(_PatternCursor& __p, _Grep_matcher(_PatternCursor& __p, _Results& __r,
_Results& __r, const _AutomatonPtr& __nfa,
const _AutomatonPtr& __nfa,
regex_constants::match_flag_type __flags) regex_constants::match_flag_type __flags)
: _M_nfa(static_pointer_cast<_Nfa>(__nfa)), _M_pattern(__p), _M_results(__r) : _M_nfa(static_pointer_cast<_Nfa>(__nfa)), _M_pattern(__p), _M_results(__r)
{ {
...@@ -142,34 +140,34 @@ namespace __regex ...@@ -142,34 +140,34 @@ namespace __regex
{ {
_StateSet __e = __s; _StateSet __e = __s;
while (!__stack.empty()) while (!__stack.empty())
{
_StateIdT __t = __stack.top(); __stack.pop();
if (__t == _S_invalid_state_id)
continue;
// for each __u with edge from __t to __u labeled e do ...
const _State& __state = _M_nfa->operator[](__t);
switch (__state._M_opcode)
{ {
case _S_opcode_alternative: _StateIdT __t = __stack.top(); __stack.pop();
__add_visited_state(__state._M_next, __stack, __e); if (__t == _S_invalid_state_id)
__add_visited_state(__state._M_alt, __stack, __e); continue;
break; // for each __u with edge from __t to __u labeled e do ...
case _S_opcode_subexpr_begin: const _State& __state = _M_nfa->operator[](__t);
__add_visited_state(__state._M_next, __stack, __e); switch (__state._M_opcode)
__state._M_tagger(_M_pattern, _M_results); {
break; case _S_opcode_alternative:
case _S_opcode_subexpr_end: __add_visited_state(__state._M_next, __stack, __e);
__add_visited_state(__state._M_next, __stack, __e); __add_visited_state(__state._M_alt, __stack, __e);
__state._M_tagger(_M_pattern, _M_results); break;
_M_results._M_set_matched(__state._M_subexpr, true); case _S_opcode_subexpr_begin:
break; __add_visited_state(__state._M_next, __stack, __e);
case _S_opcode_accept: __state._M_tagger(_M_pattern, _M_results);
__add_visited_state(__state._M_next, __stack, __e); break;
break; case _S_opcode_subexpr_end:
default: __add_visited_state(__state._M_next, __stack, __e);
break; __state._M_tagger(_M_pattern, _M_results);
_M_results._M_set_matched(__state._M_subexpr, true);
break;
case _S_opcode_accept:
__add_visited_state(__state._M_next, __stack, __e);
break;
default:
break;
}
} }
}
return __e; return __e;
} }
......
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