regex_scanner.tcc
Go to the documentation of this file.
// class template regex -*- C++ -*-
// Copyright (C) 2013-2014 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
/**
* @file bits/regex_scanner.tcc
* This is an internal header file, included by other library headers.
* Do not attempt to use it directly. @headername{regex}
*/
// FIXME make comments doxygen format.
// N3376 specified 6 regex styles: ECMAScript, basic, extended, grep, egrep
// and awk
// 1) grep is basic except '\n' is treated as '|'
// 2) egrep is extended except '\n' is treated as '|'
// 3) awk is extended except special escaping rules, and there's no
// back-reference.
//
// References:
//
// ECMAScript: ECMA-262 15.10
//
// basic, extended:
// http://pubs.opengroup.org/onlinepubs/009695399/basedefs/xbd_chap09.html
//
// awk: http://pubs.opengroup.org/onlinepubs/000095399/utilities/awk.html
namespace std _GLIBCXX_VISIBILITY(default)
{
namespace __detail
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
template<typename _FwdIter>
_Scanner<_FwdIter>::
_Scanner(_FwdIter __begin, _FwdIter __end,
_FlagT __flags, std::locale __loc)
: _M_state(_S_state_normal), _M_current(__begin), _M_end(__end),
_M_flags(__flags),
_M_ctype(std::use_facet<_CtypeT>(__loc)),
_M_at_bracket_start(false),
_M_token_map
{
{'^', _S_token_line_begin},
{'$', _S_token_line_end},
{'.', _S_token_anychar},
{'*', _S_token_closure0},
{'+', _S_token_closure1},
{'?', _S_token_opt},
{'|', _S_token_or},
// grep and egrep
{'\n', _S_token_or},
},
_M_ecma_escape_map
{
{'0', '\0'},
{'b', '\b'},
{'f', '\f'},
{'n', '\n'},
{'r', '\r'},
{'t', '\t'},
{'v', '\v'},
},
_M_awk_escape_map
{
{'"', '"'},
{'/', '/'},
{'\\', '\\'},
{'a', '\a'},
{'b', '\b'},
{'f', '\f'},
{'n', '\n'},
{'r', '\r'},
{'t', '\t'},
{'v', '\v'},
},
_M_ecma_spec_char
{
'^',
'$',
'\\',
'.',
'*',
'+',
'?',
'(',
')',
'[',
']',
'{',
'}',
'|',
},
_M_basic_spec_char
{
'.',
'[',
'\\',
'*',
'^',
'$',
},
_M_extended_spec_char
{
'.',
'[',
'\\',
'(',
')',
'*',
'+',
'?',
'{',
'|',
'^',
'$',
},
_M_escape_map(_M_is_ecma()
? _M_ecma_escape_map
: _M_awk_escape_map),
_M_spec_char(_M_is_ecma()
? _M_ecma_spec_char
: _M_is_basic()
? _M_basic_spec_char
: _M_extended_spec_char),
_M_eat_escape(_M_is_ecma()
? &_Scanner::_M_eat_escape_ecma
: &_Scanner::_M_eat_escape_posix)
{ _M_advance(); }
template<typename _FwdIter>
void
_Scanner<_FwdIter>::
_M_advance()
{
if (_M_current == _M_end)
{
_M_token = _S_token_eof;
return;
}
if (_M_state == _S_state_normal)
_M_scan_normal();
else if (_M_state == _S_state_in_bracket)
_M_scan_in_bracket();
else if (_M_state == _S_state_in_brace)
_M_scan_in_brace();
else
_GLIBCXX_DEBUG_ASSERT(false);
}
// Differences between styles:
// 1) "\(", "\)", "\{" in basic. It's not escaping.
// 2) "(?:", "(?=", "(?!" in ECMAScript.
template<typename _FwdIter>
void
_Scanner<_FwdIter>::
_M_scan_normal()
{
auto __c = *_M_current++;
if (__c == '\\')
{
if (_M_current == _M_end)
__throw_regex_error(regex_constants::error_escape);
if (!_M_is_basic()
|| (*_M_current != '('
&& *_M_current != ')'
&& *_M_current != '{'))
{
(this->*_M_eat_escape)();
return;
}
__c = *_M_current++;
}
if (__c == '(')
{
if (_M_is_ecma() && *_M_current == '?')
{
if (++_M_current == _M_end)
__throw_regex_error(regex_constants::error_paren);
if (*_M_current == ':')
{
++_M_current;
_M_token = _S_token_subexpr_no_group_begin;
}
else if (*_M_current == '=')
{
++_M_current;
_M_token = _S_token_subexpr_lookahead_begin;
_M_value.assign(1, 'p');
}
else if (*_M_current == '!')
{
++_M_current;
_M_token = _S_token_subexpr_lookahead_begin;
_M_value.assign(1, 'n');
}
else
__throw_regex_error(regex_constants::error_paren);
}
else
_M_token = _S_token_subexpr_begin;
}
else if (__c == ')')
_M_token = _S_token_subexpr_end;
else if (__c == '[')
{
_M_state = _S_state_in_bracket;
_M_at_bracket_start = true;
if (_M_current != _M_end && *_M_current == '^')
{
_M_token = _S_token_bracket_neg_begin;
++_M_current;
}
else
_M_token = _S_token_bracket_begin;
}
else if (__c == '{')
{
_M_state = _S_state_in_brace;
_M_token = _S_token_interval_begin;
}
else if ((_M_spec_char.count(_M_ctype.narrow(__c, '\0'))
&& __c != ']'
&& __c != '}')
|| (_M_is_grep() && __c == '\n'))
_M_token = _M_token_map.at(__c);
else
{
_M_token = _S_token_ord_char;
_M_value.assign(1, __c);
}
}
// Differences between styles:
// 1) different semantics of "[]" and "[^]".
// 2) Escaping in bracket expr.
template<typename _FwdIter>
void
_Scanner<_FwdIter>::
_M_scan_in_bracket()
{
if (_M_current == _M_end)
__throw_regex_error(regex_constants::error_brack);
auto __c = *_M_current++;
if (__c == '[')
{
if (_M_current == _M_end)
__throw_regex_error(regex_constants::error_brack);
if (*_M_current == '.')
{
_M_token = _S_token_collsymbol;
_M_eat_class(*_M_current++);
}
else if (*_M_current == ':')
{
_M_token = _S_token_char_class_name;
_M_eat_class(*_M_current++);
}
else if (*_M_current == '=')
{
_M_token = _S_token_equiv_class_name;
_M_eat_class(*_M_current++);
}
else
{
_M_token = _S_token_ord_char;
_M_value.assign(1, __c);
}
}
// In POSIX, when encountering "[]" or "[^]", the ']' is interpreted
// literally. So "[]]" or "[^]]" is valid regex. See the testcases
// `*/empty_range.cc`.
else if (__c == ']' && (_M_is_ecma() || !_M_at_bracket_start))
{
_M_token = _S_token_bracket_end;
_M_state = _S_state_normal;
}
// ECMAScirpt and awk permmits escaping in bracket.
else if (__c == '\\' && (_M_is_ecma() || _M_is_awk()))
(this->*_M_eat_escape)();
else
{
_M_token = _S_token_ord_char;
_M_value.assign(1, __c);
}
_M_at_bracket_start = false;
}
// Differences between styles:
// 1) "\}" in basic style.
template<typename _FwdIter>
void
_Scanner<_FwdIter>::
_M_scan_in_brace()
{
if (_M_current == _M_end)
__throw_regex_error(regex_constants::error_brace);
auto __c = *_M_current++;
if (_M_ctype.is(_CtypeT::digit, __c))
{
_M_token = _S_token_dup_count;
_M_value.assign(1, __c);
while (_M_current != _M_end
&& _M_ctype.is(_CtypeT::digit, *_M_current))
_M_value += *_M_current++;
}
else if (__c == ',')
_M_token = _S_token_comma;
// basic use \}.
else if (_M_is_basic())
{
if (__c == '\\' && _M_current != _M_end && *_M_current == '}')
{
_M_state = _S_state_normal;
_M_token = _S_token_interval_end;
++_M_current;
}
else
__throw_regex_error(regex_constants::error_badbrace);
}
else if (__c == '}')
{
_M_state = _S_state_normal;
_M_token = _S_token_interval_end;
}
else
__throw_regex_error(regex_constants::error_badbrace);
}
template<typename _FwdIter>
void
_Scanner<_FwdIter>::
_M_eat_escape_ecma()
{
if (_M_current == _M_end)
__throw_regex_error(regex_constants::error_escape);
auto __c = *_M_current++;
if (_M_escape_map.count(_M_ctype.narrow(__c, '\0'))
&& (__c != 'b' || _M_state == _S_state_in_bracket))
{
_M_token = _S_token_ord_char;
_M_value.assign(1, _M_escape_map.at(__c));
}
else if (__c == 'b')
{
_M_token = _S_token_word_bound;
_M_value.assign(1, 'p');
}
else if (__c == 'B')
{
_M_token = _S_token_word_bound;
_M_value.assign(1, 'n');
}
// N3376 28.13
else if (__c == 'd'
|| __c == 'D'
|| __c == 's'
|| __c == 'S'
|| __c == 'w'
|| __c == 'W')
{
_M_token = _S_token_quoted_class;
_M_value.assign(1, __c);
}
else if (__c == 'c')
{
if (_M_current == _M_end)
__throw_regex_error(regex_constants::error_escape);
_M_token = _S_token_ord_char;
_M_value.assign(1, *_M_current++);
}
else if (__c == 'x' || __c == 'u')
{
_M_value.erase();
for (int i = 0; i < (__c == 'x' ? 2 : 4); i++)
{
if (_M_current == _M_end
|| !_M_ctype.is(_CtypeT::xdigit, *_M_current))
__throw_regex_error(regex_constants::error_escape);
_M_value += *_M_current++;
}
_M_token = _S_token_hex_num;
}
// ECMAScript recongnizes multi-digit back-references.
else if (_M_ctype.is(_CtypeT::digit, __c))
{
_M_value.assign(1, __c);
while (_M_current != _M_end
&& _M_ctype.is(_CtypeT::digit, *_M_current))
_M_value += *_M_current++;
_M_token = _S_token_backref;
}
else
{
_M_token = _S_token_ord_char;
_M_value.assign(1, __c);
}
}
// Differences between styles:
// 1) Extended doesn't support backref, but basic does.
template<typename _FwdIter>
void
_Scanner<_FwdIter>::
_M_eat_escape_posix()
{
if (_M_current == _M_end)
__throw_regex_error(regex_constants::error_escape);
auto __c = *_M_current;
if (_M_spec_char.count(_M_ctype.narrow(__c, '\0')))
{
_M_token = _S_token_ord_char;
_M_value.assign(1, __c);
}
// We MUST judge awk before handling backrefs. There's no backref in awk.
else if (_M_is_awk())
{
_M_eat_escape_awk();
return;
}
else if (_M_is_basic() && _M_ctype.is(_CtypeT::digit, __c) && __c != '0')
{
_M_token = _S_token_backref;
_M_value.assign(1, __c);
}
else
{
#ifdef __STRICT_ANSI__
__throw_regex_error(regex_constants::error_escape);
#else
_M_token = _S_token_ord_char;
_M_value.assign(1, __c);
#endif
}
++_M_current;
}
template<typename _FwdIter>
void
_Scanner<_FwdIter>::
_M_eat_escape_awk()
{
auto __c = *_M_current++;
if (_M_escape_map.count(_M_ctype.narrow(__c, '\0')))
{
_M_token = _S_token_ord_char;
_M_value.assign(1, _M_escape_map.at(__c));
}
// \ddd for oct representation
else if (_M_ctype.is(_CtypeT::digit, __c)
&& __c != '8'
&& __c != '9')
{
_M_value.assign(1, __c);
for (int __i = 0;
__i < 2
&& _M_current != _M_end
&& _M_ctype.is(_CtypeT::digit, *_M_current)
&& *_M_current != '8'
&& *_M_current != '9';
__i++)
_M_value += *_M_current++;
_M_token = _S_token_oct_num;
return;
}
else
__throw_regex_error(regex_constants::error_escape);
}
// Eats a character class or throwns an exception.
// __ch cound be ':', '.' or '=', _M_current is the char after ']' when
// returning.
template<typename _FwdIter>
void
_Scanner<_FwdIter>::
_M_eat_class(char __ch)
{
for (_M_value.clear(); _M_current != _M_end && *_M_current != __ch;)
_M_value += *_M_current++;
if (_M_current == _M_end
|| *_M_current++ != __ch
|| _M_current == _M_end // skip __ch
|| *_M_current++ != ']') // skip ']'
{
if (__ch == ':')
__throw_regex_error(regex_constants::error_ctype);
else
__throw_regex_error(regex_constants::error_collate);
}
}
#ifdef _GLIBCXX_DEBUG
template<typename _FwdIter>
std::ostream&
_Scanner<_FwdIter>::
_M_print(std::ostream& ostr)
{
switch (_M_token)
{
case _S_token_anychar:
ostr << "any-character\n";
break;
case _S_token_backref:
ostr << "backref\n";
break;
case _S_token_bracket_begin:
ostr << "bracket-begin\n";
break;
case _S_token_bracket_neg_begin:
ostr << "bracket-neg-begin\n";
break;
case _S_token_bracket_end:
ostr << "bracket-end\n";
break;
case _S_token_char_class_name:
ostr << "char-class-name \"" << _M_value << "\"\n";
break;
case _S_token_closure0:
ostr << "closure0\n";
break;
case _S_token_closure1:
ostr << "closure1\n";
break;
case _S_token_collsymbol:
ostr << "collsymbol \"" << _M_value << "\"\n";
break;
case _S_token_comma:
ostr << "comma\n";
break;
case _S_token_dup_count:
ostr << "dup count: " << _M_value << "\n";
break;
case _S_token_eof:
ostr << "EOF\n";
break;
case _S_token_equiv_class_name:
ostr << "equiv-class-name \"" << _M_value << "\"\n";
break;
case _S_token_interval_begin:
ostr << "interval begin\n";
break;
case _S_token_interval_end:
ostr << "interval end\n";
break;
case _S_token_line_begin:
ostr << "line begin\n";
break;
case _S_token_line_end:
ostr << "line end\n";
break;
case _S_token_opt:
ostr << "opt\n";
break;
case _S_token_or:
ostr << "or\n";
break;
case _S_token_ord_char:
ostr << "ordinary character: \"" << _M_value << "\"\n";
break;
case _S_token_subexpr_begin:
ostr << "subexpr begin\n";
break;
case _S_token_subexpr_no_group_begin:
ostr << "no grouping subexpr begin\n";
break;
case _S_token_subexpr_lookahead_begin:
ostr << "lookahead subexpr begin\n";
break;
case _S_token_subexpr_end:
ostr << "subexpr end\n";
break;
case _S_token_unknown:
ostr << "-- unknown token --\n";
break;
case _S_token_oct_num:
ostr << "oct number " << _M_value << "\n";
break;
case _S_token_hex_num:
ostr << "hex number " << _M_value << "\n";
break;
case _S_token_quoted_class:
ostr << "quoted class " << "\\" << _M_value << "\n";
break;
default:
_GLIBCXX_DEBUG_ASSERT(false);
}
return ostr;
}
#endif
_GLIBCXX_END_NAMESPACE_VERSION
} // namespace __detail
} // namespace
std::regex_constants::error_ctype
constexpr error_type error_ctype(_S_error_ctype)
std::use_facet
const _Facet & use_facet(const locale &__loc)
Return a facet.use_facet looks for and returns a reference to a facet of type Facet where Facet is th...
Definition: locale_classes.tcc:132
std::locale
Container class for localization functionality.The locale class is first a class wrapper for C librar...
Definition: locale_classes.h:62
std::regex_constants::error_brack
constexpr error_type error_brack(_S_error_brack)
std::regex_constants::error_badbrace
constexpr error_type error_badbrace(_S_error_badbrace)
std::regex_constants::error_collate
constexpr error_type error_collate(_S_error_collate)
std::regex_constants::error_paren
constexpr error_type error_paren(_S_error_paren)
std::basic_ostream< char >
std::regex_constants::error_escape
constexpr error_type error_escape(_S_error_escape)
std::regex_constants::error_brace
constexpr error_type error_brace(_S_error_brace)