11.2.0/bits/regex_error.h

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

// Copyright (C) 2010-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_error.h
 * @brief Error and exception objects for the std regex library.
 *
 *  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

/**
 * @addtogroup regex
 * @{
 */

namespace regex_constants
{
  /**
   * @name 5.3 Error Types
   */
  ///@{

  enum error_type
    {
      _S_error_collate,
      _S_error_ctype,
      _S_error_escape,
      _S_error_backref,
      _S_error_brack,
      _S_error_paren,
      _S_error_brace,
      _S_error_badbrace,
      _S_error_range,
      _S_error_space,
      _S_error_badrepeat,
      _S_error_complexity,
      _S_error_stack,
    };

  /** The expression contained an invalid collating element name. */
  constexpr error_type error_collate(_S_error_collate);

  /** The expression contained an invalid character class name. */
  constexpr error_type error_ctype(_S_error_ctype);

  /**
   * The expression contained an invalid escaped character, or a trailing
   * escape.
   */
  constexpr error_type error_escape(_S_error_escape);

  /** The expression contained an invalid back reference. */
  constexpr error_type error_backref(_S_error_backref);

  /** The expression contained mismatched [ and ]. */
  constexpr error_type error_brack(_S_error_brack);

  /** The expression contained mismatched ( and ). */
  constexpr error_type error_paren(_S_error_paren);

  /** The expression contained mismatched { and } */
  constexpr error_type error_brace(_S_error_brace);

  /** The expression contained an invalid range in a {} expression. */
  constexpr error_type error_badbrace(_S_error_badbrace);

  /**
   * The expression contained an invalid character range,
   * such as [b-a] in most encodings.
   */
  constexpr error_type error_range(_S_error_range);

  /**
   * There was insufficient memory to convert the expression into a
   * finite state machine.
   */
  constexpr error_type error_space(_S_error_space);

  /**
   * One of <em>*?+{</em> was not preceded by a valid regular expression.
   */
  constexpr error_type error_badrepeat(_S_error_badrepeat);

  /**
   * The complexity of an attempted match against a regular expression
   * exceeded a pre-set level.
   */
  constexpr error_type error_complexity(_S_error_complexity);

  /**
   * There was insufficient memory to determine whether the
   * regular expression could match the specified character sequence.
   */
  constexpr error_type error_stack(_S_error_stack);

  ///@}
} // namespace regex_constants

  // [7.8] Class regex_error
  /**
   * @brief A regular expression exception class.
   * @ingroup exceptions
   *
   * The regular expression library throws objects of this class on error.
   */
  class regex_error : public std::runtime_error
  {
    regex_constants::error_type _M_code;

  public:
    /**
     * @brief Constructs a regex_error object.
     *
     * @param __ecode the regex error code.
     */
    explicit
    regex_error(regex_constants::error_type __ecode);

    virtual ~regex_error() throw();

    /**
     * @brief Gets the regex error code.
     *
     * @returns the regex error code.
     */
    regex_constants::error_type
    code() const
    { return _M_code; }

  private:
    regex_error(regex_constants::error_type __ecode, const char* __what)
    : std::runtime_error(__what), _M_code(__ecode)
    { }

    friend void __throw_regex_error(regex_constants::error_type, const char*);
  };

  ///@} // group regex

  void
  __throw_regex_error(regex_constants::error_type __ecode);

  inline void
  __throw_regex_error(regex_constants::error_type __ecode
                        __attribute__((__unused__)),
                      const char* __what __attribute__((__unused__)))
  { _GLIBCXX_THROW_OR_ABORT(regex_error(__ecode, __what)); }

_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
Revision:	1166
Committed:	Tue Oct 26 14:22:36 2021 UTC (4 years ago) by rossy
Content type:	text/x-chdr
File size:	4974 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) 2010-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_error.h
27	* @brief Error and exception objects for the std regex library.
28	*
29	* This is an internal header file, included by other library headers.
30	* Do not attempt to use it directly. @headername{regex}
31	*/
32
33	namespace std _GLIBCXX_VISIBILITY(default)
34	{
35	_GLIBCXX_BEGIN_NAMESPACE_VERSION
36
37	/**
38	* @addtogroup regex
39	* @{
40	*/
41
42	namespace regex_constants
43	{
44	/**
45	* @name 5.3 Error Types
46	*/
47	///@{
48
49	enum error_type
50	{
51	_S_error_collate,
52	_S_error_ctype,
53	_S_error_escape,
54	_S_error_backref,
55	_S_error_brack,
56	_S_error_paren,
57	_S_error_brace,
58	_S_error_badbrace,
59	_S_error_range,
60	_S_error_space,
61	_S_error_badrepeat,
62	_S_error_complexity,
63	_S_error_stack,
64	};
65
66	/** The expression contained an invalid collating element name. */
67	constexpr error_type error_collate(_S_error_collate);
68
69	/** The expression contained an invalid character class name. */
70	constexpr error_type error_ctype(_S_error_ctype);
71
72	/**
73	* The expression contained an invalid escaped character, or a trailing
74	* escape.
75	*/
76	constexpr error_type error_escape(_S_error_escape);
77
78	/** The expression contained an invalid back reference. */
79	constexpr error_type error_backref(_S_error_backref);
80
81	/** The expression contained mismatched [ and ]. */
82	constexpr error_type error_brack(_S_error_brack);
83
84	/** The expression contained mismatched ( and ). */
85	constexpr error_type error_paren(_S_error_paren);
86
87	/** The expression contained mismatched { and } */
88	constexpr error_type error_brace(_S_error_brace);
89
90	/** The expression contained an invalid range in a {} expression. */
91	constexpr error_type error_badbrace(_S_error_badbrace);
92
93	/**
94	* The expression contained an invalid character range,
95	* such as [b-a] in most encodings.
96	*/
97	constexpr error_type error_range(_S_error_range);
98
99	/**
100	* There was insufficient memory to convert the expression into a
101	* finite state machine.
102	*/
103	constexpr error_type error_space(_S_error_space);
104
105	/**
106	* One of <em>*?+{</em> was not preceded by a valid regular expression.
107	*/
108	constexpr error_type error_badrepeat(_S_error_badrepeat);
109
110	/**
111	* The complexity of an attempted match against a regular expression
112	* exceeded a pre-set level.
113	*/
114	constexpr error_type error_complexity(_S_error_complexity);
115
116	/**
117	* There was insufficient memory to determine whether the
118	* regular expression could match the specified character sequence.
119	*/
120	constexpr error_type error_stack(_S_error_stack);
121
122	///@}
123	} // namespace regex_constants
124
125	// [7.8] Class regex_error
126	/**
127	* @brief A regular expression exception class.
128	* @ingroup exceptions
129	*
130	* The regular expression library throws objects of this class on error.
131	*/
132	class regex_error : public std::runtime_error
133	{
134	regex_constants::error_type _M_code;
135
136	public:
137	/**
138	* @brief Constructs a regex_error object.
139	*
140	* @param __ecode the regex error code.
141	*/
142	explicit
143	regex_error(regex_constants::error_type __ecode);
144
145	virtual ~regex_error() throw();
146
147	/**
148	* @brief Gets the regex error code.
149	*
150	* @returns the regex error code.
151	*/
152	regex_constants::error_type
153	code() const
154	{ return _M_code; }
155
156	private:
157	regex_error(regex_constants::error_type __ecode, const char* __what)
158	: std::runtime_error(__what), _M_code(__ecode)
159	{ }
160
161	friend void __throw_regex_error(regex_constants::error_type, const char*);
162	};
163
164	///@} // group regex
165
166	void
167	__throw_regex_error(regex_constants::error_type __ecode);
168
169	inline void
170	__throw_regex_error(regex_constants::error_type __ecode
171	__attribute__((__unused__)),
172	const char* __what __attribute__((__unused__)))
173	{ _GLIBCXX_THROW_OR_ABORT(regex_error(__ecode, __what)); }
174
175	_GLIBCXX_END_NAMESPACE_VERSION
176	} // namespace std