11.2.0/bits/regex_scanner.h

// class template regex -*- C++ -*-

// Copyright (C) 2013-2021 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.h
 *  This is an internal header file, included by other library headers.
 *  Do not attempt to use it directly. @headername{regex}
 */

namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION

namespace __detail
{
  /**
   * @addtogroup regex-detail
   * @{
   */

  struct _ScannerBase
  {
  public:
    /// Token types returned from the scanner.
    enum _TokenT : unsigned
    {
      _S_token_anychar,
      _S_token_ord_char,
      _S_token_oct_num,
      _S_token_hex_num,
      _S_token_backref,
      _S_token_subexpr_begin,
      _S_token_subexpr_no_group_begin,
      _S_token_subexpr_lookahead_begin, // neg if _M_value[0] == 'n'
      _S_token_subexpr_end,
      _S_token_bracket_begin,
      _S_token_bracket_neg_begin,
      _S_token_bracket_end,
      _S_token_interval_begin,
      _S_token_interval_end,
      _S_token_quoted_class,
      _S_token_char_class_name,
      _S_token_collsymbol,
      _S_token_equiv_class_name,
      _S_token_opt,
      _S_token_or,
      _S_token_closure0,
      _S_token_closure1,
      _S_token_line_begin,
      _S_token_line_end,
      _S_token_word_bound, // neg if _M_value[0] == 'n'
      _S_token_comma,
      _S_token_dup_count,
      _S_token_eof,
      _S_token_bracket_dash,
      _S_token_unknown = -1u
    };

  protected:
    typedef regex_constants::syntax_option_type _FlagT;

    enum _StateT
    {
      _S_state_normal,
      _S_state_in_brace,
      _S_state_in_bracket,
    };

  protected:
    _ScannerBase(_FlagT __flags)
    : _M_state(_S_state_normal),
    _M_flags(__flags),
    _M_escape_tbl(_M_is_ecma()
                  ? _M_ecma_escape_tbl
                  : _M_awk_escape_tbl),
    _M_spec_char(_M_is_ecma()
                 ? _M_ecma_spec_char
                 : _M_flags & regex_constants::basic
                 ? _M_basic_spec_char
                 : _M_flags & regex_constants::extended
                 ? _M_extended_spec_char
                 : _M_flags & regex_constants::grep
                 ?  ".[\\*^$\n"
                 : _M_flags & regex_constants::egrep
                 ? ".[\\()*+?{|^$\n"
                 : _M_flags & regex_constants::awk
                 ? _M_extended_spec_char
                 : nullptr),
    _M_at_bracket_start(false)
    { __glibcxx_assert(_M_spec_char); }

  protected:
    const char*
    _M_find_escape(char __c)
    {
      auto __it = _M_escape_tbl;
      for (; __it->first != '\0'; ++__it)
        if (__it->first == __c)
          return &__it->second;
      return nullptr;
    }

    bool
    _M_is_ecma() const
    { return _M_flags & regex_constants::ECMAScript; }

    bool
    _M_is_basic() const
    { return _M_flags & (regex_constants::basic | regex_constants::grep); }

    bool
    _M_is_extended() const
    {
      return _M_flags & (regex_constants::extended
                         | regex_constants::egrep
                         | regex_constants::awk);
    }

    bool
    _M_is_grep() const
    { return _M_flags & (regex_constants::grep | regex_constants::egrep); }

    bool
    _M_is_awk() const
    { return _M_flags & regex_constants::awk; }

  protected:
    // TODO: Make them static in the next abi change.
    const std::pair<char, _TokenT> _M_token_tbl[9] =
      {
        {'^', _S_token_line_begin},
        {'$', _S_token_line_end},
        {'.', _S_token_anychar},
        {'*', _S_token_closure0},
        {'+', _S_token_closure1},
        {'?', _S_token_opt},
        {'|', _S_token_or},
        {'\n', _S_token_or}, // grep and egrep
        {'\0', _S_token_or},
      };
    const std::pair<char, char> _M_ecma_escape_tbl[8] =
      {
        {'0', '\0'},
        {'b', '\b'},
        {'f', '\f'},
        {'n', '\n'},
        {'r', '\r'},
        {'t', '\t'},
        {'v', '\v'},
        {'\0', '\0'},
      };
    const std::pair<char, char> _M_awk_escape_tbl[11] =
      {
        {'"', '"'},
        {'/', '/'},
        {'\\', '\\'},
        {'a', '\a'},
        {'b', '\b'},
        {'f', '\f'},
        {'n', '\n'},
        {'r', '\r'},
        {'t', '\t'},
        {'v', '\v'},
        {'\0', '\0'},
      };
    const char* _M_ecma_spec_char = "^$\\.*+?()[]{}|";
    const char* _M_basic_spec_char = ".[\\*^$";
    const char* _M_extended_spec_char = ".[\\()*+?{|^$";

    _StateT                       _M_state;
    _FlagT                        _M_flags;
    _TokenT                       _M_token;
    const std::pair<char, char>*  _M_escape_tbl;
    const char*                   _M_spec_char;
    bool                          _M_at_bracket_start;
  };

  /**
   * @brief Scans an input range for regex tokens.
   *
   * The %_Scanner class interprets the regular expression pattern in
   * the input range passed to its constructor as a sequence of parse
   * tokens passed to the regular expression compiler.  The sequence
   * of tokens provided depends on the flag settings passed to the
   * constructor: different regular expression grammars will interpret
   * the same input pattern in syntactically different ways.
   */
  template<typename _CharT>
    class _Scanner
    : public _ScannerBase
    {
    public:
      typedef const _CharT*                                       _IterT;
      typedef std::basic_string<_CharT>                           _StringT;
      typedef regex_constants::syntax_option_type                 _FlagT;
      typedef const std::ctype<_CharT>                            _CtypeT;

      _Scanner(_IterT __begin, _IterT __end,
               _FlagT __flags, std::locale __loc);

      void
      _M_advance();

      _TokenT
      _M_get_token() const
      { return _M_token; }

      const _StringT&
      _M_get_value() const
      { return _M_value; }

#ifdef _GLIBCXX_DEBUG
      std::ostream&
      _M_print(std::ostream&);
#endif

    private:
      void
      _M_scan_normal();

      void
      _M_scan_in_bracket();

      void
      _M_scan_in_brace();

      void
      _M_eat_escape_ecma();

      void
      _M_eat_escape_posix();

      void
      _M_eat_escape_awk();

      void
      _M_eat_class(char);

      _IterT                        _M_current;
      _IterT                        _M_end;
      _CtypeT&                      _M_ctype;
      _StringT                      _M_value;
      void (_Scanner::* _M_eat_escape)();
    };

 ///@} regex-detail
} // namespace __detail
_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std

#include <bits/regex_scanner.tcc>
Revision:	1166
Committed:	Tue Oct 26 14:22:36 2021 UTC (4 years ago) by rossy
Content type:	text/x-chdr
File size:	7089 byte(s)
Log Message:	Daodan: Replace MinGW build env with an up-to-date MSYS2 env
#	Content
1	// class template regex -- C++ --
2
3	// Copyright (C) 2013-2021 Free Software Foundation, Inc.
4	//
5	// This file is part of the GNU ISO C++ Library. This library is free
6	// software; you can redistribute it and/or modify it under the
7	// terms of the GNU General Public License as published by the
8	// Free Software Foundation; either version 3, or (at your option)
9	// any later version.
10
11	// This library is distributed in the hope that it will be useful,
12	// but WITHOUT ANY WARRANTY; without even the implied warranty of
13	// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14	// GNU General Public License for more details.
15
16	// Under Section 7 of GPL version 3, you are granted additional
17	// permissions described in the GCC Runtime Library Exception, version
18	// 3.1, as published by the Free Software Foundation.
19
20	// You should have received a copy of the GNU General Public License and
21	// a copy of the GCC Runtime Library Exception along with this program;
22	// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
23	// <http://www.gnu.org/licenses/>.
24
25	/**
26	* @file bits/regex_scanner.h
27	* This is an internal header file, included by other library headers.
28	* Do not attempt to use it directly. @headername{regex}
29	*/
30
31	namespace std _GLIBCXX_VISIBILITY(default)
32	{
33	_GLIBCXX_BEGIN_NAMESPACE_VERSION
34
35	namespace __detail
36	{
37	/**
38	* @addtogroup regex-detail
39	* @{
40	*/
41
42	struct _ScannerBase
43	{
44	public:
45	/// Token types returned from the scanner.
46	enum _TokenT : unsigned
47	{
48	_S_token_anychar,
49	_S_token_ord_char,
50	_S_token_oct_num,
51	_S_token_hex_num,
52	_S_token_backref,
53	_S_token_subexpr_begin,
54	_S_token_subexpr_no_group_begin,
55	_S_token_subexpr_lookahead_begin, // neg if _M_value[0] == 'n'
56	_S_token_subexpr_end,
57	_S_token_bracket_begin,
58	_S_token_bracket_neg_begin,
59	_S_token_bracket_end,
60	_S_token_interval_begin,
61	_S_token_interval_end,
62	_S_token_quoted_class,
63	_S_token_char_class_name,
64	_S_token_collsymbol,
65	_S_token_equiv_class_name,
66	_S_token_opt,
67	_S_token_or,
68	_S_token_closure0,
69	_S_token_closure1,
70	_S_token_line_begin,
71	_S_token_line_end,
72	_S_token_word_bound, // neg if _M_value[0] == 'n'
73	_S_token_comma,
74	_S_token_dup_count,
75	_S_token_eof,
76	_S_token_bracket_dash,
77	_S_token_unknown = -1u
78	};
79
80	protected:
81	typedef regex_constants::syntax_option_type _FlagT;
82
83	enum _StateT
84	{
85	_S_state_normal,
86	_S_state_in_brace,
87	_S_state_in_bracket,
88	};
89
90	protected:
91	_ScannerBase(_FlagT __flags)
92	: _M_state(_S_state_normal),
93	_M_flags(__flags),
94	_M_escape_tbl(_M_is_ecma()
95	? _M_ecma_escape_tbl
96	: _M_awk_escape_tbl),
97	_M_spec_char(_M_is_ecma()
98	? _M_ecma_spec_char
99	: _M_flags & regex_constants::basic
100	? _M_basic_spec_char
101	: _M_flags & regex_constants::extended
102	? _M_extended_spec_char
103	: _M_flags & regex_constants::grep
104	? ".[\\*^$\n"
105	: _M_flags & regex_constants::egrep
106	? ".[\\()*+?{\|^$\n"
107	: _M_flags & regex_constants::awk
108	? _M_extended_spec_char
109	: nullptr),
110	_M_at_bracket_start(false)
111	{ __glibcxx_assert(_M_spec_char); }
112
113	protected:
114	const char*
115	_M_find_escape(char __c)
116	{
117	auto __it = _M_escape_tbl;
118	for (; __it->first != '\0'; ++__it)
119	if (__it->first == __c)
120	return &__it->second;
121	return nullptr;
122	}
123
124	bool
125	_M_is_ecma() const
126	{ return _M_flags & regex_constants::ECMAScript; }
127
128	bool
129	_M_is_basic() const
130	{ return _M_flags & (regex_constants::basic \| regex_constants::grep); }
131
132	bool
133	_M_is_extended() const
134	{
135	return _M_flags & (regex_constants::extended
136	\| regex_constants::egrep
137	\| regex_constants::awk);
138	}
139
140	bool
141	_M_is_grep() const
142	{ return _M_flags & (regex_constants::grep \| regex_constants::egrep); }
143
144	bool
145	_M_is_awk() const
146	{ return _M_flags & regex_constants::awk; }
147
148	protected:
149	// TODO: Make them static in the next abi change.
150	const std::pair<char, _TokenT> _M_token_tbl[9] =
151	{
152	{'^', _S_token_line_begin},
153	{'$', _S_token_line_end},
154	{'.', _S_token_anychar},
155	{'*', _S_token_closure0},
156	{'+', _S_token_closure1},
157	{'?', _S_token_opt},
158	{'\|', _S_token_or},
159	{'\n', _S_token_or}, // grep and egrep
160	{'\0', _S_token_or},
161	};
162	const std::pair<char, char> _M_ecma_escape_tbl[8] =
163	{
164	{'0', '\0'},
165	{'b', '\b'},
166	{'f', '\f'},
167	{'n', '\n'},
168	{'r', '\r'},
169	{'t', '\t'},
170	{'v', '\v'},
171	{'\0', '\0'},
172	};
173	const std::pair<char, char> _M_awk_escape_tbl[11] =
174	{
175	{'"', '"'},
176	{'/', '/'},
177	{'\\', '\\'},
178	{'a', '\a'},
179	{'b', '\b'},
180	{'f', '\f'},
181	{'n', '\n'},
182	{'r', '\r'},
183	{'t', '\t'},
184	{'v', '\v'},
185	{'\0', '\0'},
186	};
187	const char* _M_ecma_spec_char = "^$\\.*+?()[]{}\|";
188	const char* _M_basic_spec_char = ".[\\*^$";
189	const char* _M_extended_spec_char = ".[\\()*+?{\|^$";
190
191	_StateT _M_state;
192	_FlagT _M_flags;
193	_TokenT _M_token;
194	const std::pair<char, char>* _M_escape_tbl;
195	const char* _M_spec_char;
196	bool _M_at_bracket_start;
197	};
198
199	/**
200	* @brief Scans an input range for regex tokens.
201	*
202	* The %_Scanner class interprets the regular expression pattern in
203	* the input range passed to its constructor as a sequence of parse
204	* tokens passed to the regular expression compiler. The sequence
205	* of tokens provided depends on the flag settings passed to the
206	* constructor: different regular expression grammars will interpret
207	* the same input pattern in syntactically different ways.
208	*/
209	template<typename _CharT>
210	class _Scanner
211	: public _ScannerBase
212	{
213	public:
214	typedef const _CharT* _IterT;
215	typedef std::basic_string<_CharT> _StringT;
216	typedef regex_constants::syntax_option_type _FlagT;
217	typedef const std::ctype<_CharT> _CtypeT;
218
219	_Scanner(_IterT __begin, _IterT __end,
220	_FlagT __flags, std::locale __loc);
221
222	void
223	_M_advance();
224
225	_TokenT
226	_M_get_token() const
227	{ return _M_token; }
228
229	const _StringT&
230	_M_get_value() const
231	{ return _M_value; }
232
233	#ifdef _GLIBCXX_DEBUG
234	std::ostream&
235	_M_print(std::ostream&);
236	#endif
237
238	private:
239	void
240	_M_scan_normal();
241
242	void
243	_M_scan_in_bracket();
244
245	void
246	_M_scan_in_brace();
247
248	void
249	_M_eat_escape_ecma();
250
251	void
252	_M_eat_escape_posix();
253
254	void
255	_M_eat_escape_awk();
256
257	void
258	_M_eat_class(char);
259
260	_IterT _M_current;
261	_IterT _M_end;
262	_CtypeT& _M_ctype;
263	_StringT _M_value;
264	void (_Scanner::* _M_eat_escape)();
265	};
266
267	///@} regex-detail
268	} // namespace __detail
269	_GLIBCXX_END_NAMESPACE_VERSION
270	} // namespace std
271
272	#include <bits/regex_scanner.tcc>