1// Standard exception classes -*- C++ -*-
2
3// Copyright (C) 2001-2022 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/** @file include/stdexcept
26 * This is a Standard C++ Library header.
27 */
28
29//
30// ISO C++ 19.1 Exception classes
31//
32
33#ifndef _GLIBCXX_STDEXCEPT
34#define _GLIBCXX_STDEXCEPT 1
35
36#pragma GCC system_header
37
38#include <exception>
39#include <string>
40
41namespace std _GLIBCXX_VISIBILITY(default)
42{
43_GLIBCXX_BEGIN_NAMESPACE_VERSION
44
45#if _GLIBCXX_USE_DUAL_ABI
46#if _GLIBCXX_USE_CXX11_ABI
47 // Emulates an old COW string when the new std::string is in use.
48 struct __cow_string
49 {
50 union {
51 const char* _M_p;
52 char _M_bytes[sizeof(const char*)];
53 };
54
55 __cow_string();
56 __cow_string(const std::string&);
57 __cow_string(const char*, size_t);
58 __cow_string(const __cow_string&) _GLIBCXX_NOTHROW;
59 __cow_string& operator=(const __cow_string&) _GLIBCXX_NOTHROW;
60 ~__cow_string();
61#if __cplusplus >= 201103L
62 __cow_string(__cow_string&&) noexcept;
63 __cow_string& operator=(__cow_string&&) noexcept;
64#endif
65 };
66
67 typedef basic_string<char> __sso_string;
68#else // _GLIBCXX_USE_CXX11_ABI
69 typedef basic_string<char> __cow_string;
70
71 // Emulates a new SSO string when the old std::string is in use.
72 struct __sso_string
73 {
74 struct __str
75 {
76 const char* _M_p;
77 size_t _M_string_length;
78 char _M_local_buf[16];
79 };
80
81 union {
82 __str _M_s;
83 char _M_bytes[sizeof(__str)];
84 };
85
86 __sso_string() _GLIBCXX_NOTHROW;
87 __sso_string(const std::string&);
88 __sso_string(const char*, size_t);
89 __sso_string(const __sso_string&);
90 __sso_string& operator=(const __sso_string&);
91 ~__sso_string();
92#if __cplusplus >= 201103L
93 __sso_string(__sso_string&&) noexcept;
94 __sso_string& operator=(__sso_string&&) noexcept;
95#endif
96 };
97#endif // _GLIBCXX_USE_CXX11_ABI
98#else // _GLIBCXX_USE_DUAL_ABI
99 typedef basic_string<char> __sso_string;
100 typedef basic_string<char> __cow_string;
101#endif
102
103 /**
104 * @addtogroup exceptions
105 * @{
106 */
107
108 /** Logic errors represent problems in the internal logic of a program;
109 * in theory, these are preventable, and even detectable before the
110 * program runs (e.g., violations of class invariants).
111 * @brief One of two subclasses of exception.
112 */
113 class logic_error : public exception
114 {
115 __cow_string _M_msg;
116
117 public:
118 /** Takes a character string describing the error. */
119 explicit
120 logic_error(const string& __arg) _GLIBCXX_TXN_SAFE;
121
122#if __cplusplus >= 201103L
123 explicit
124 logic_error(const char*) _GLIBCXX_TXN_SAFE;
125
126 logic_error(logic_error&&) noexcept;
127 logic_error& operator=(logic_error&&) noexcept;
128#endif
129
130#if _GLIBCXX_USE_CXX11_ABI || _GLIBCXX_DEFINE_STDEXCEPT_COPY_OPS
131 logic_error(const logic_error&) _GLIBCXX_NOTHROW;
132 logic_error& operator=(const logic_error&) _GLIBCXX_NOTHROW;
133#elif __cplusplus >= 201103L
134 logic_error(const logic_error&) = default;
135 logic_error& operator=(const logic_error&) = default;
136#endif
137
138 virtual ~logic_error() _GLIBCXX_TXN_SAFE_DYN _GLIBCXX_NOTHROW;
139
140 /** Returns a C-style character string describing the general cause of
141 * the current error (the same string passed to the ctor). */
142 virtual const char*
143 what() const _GLIBCXX_TXN_SAFE_DYN _GLIBCXX_NOTHROW;
144
145# ifdef _GLIBCXX_TM_TS_INTERNAL
146 friend void*
147 ::_txnal_logic_error_get_msg(void* e);
148# endif
149 };
150
151 /** Thrown by the library, or by you, to report domain errors (domain in
152 * the mathematical sense). */
153 class domain_error : public logic_error
154 {
155 public:
156 explicit domain_error(const string& __arg) _GLIBCXX_TXN_SAFE;
157#if __cplusplus >= 201103L
158 explicit domain_error(const char*) _GLIBCXX_TXN_SAFE;
159 domain_error(const domain_error&) = default;
160 domain_error& operator=(const domain_error&) = default;
161 domain_error(domain_error&&) = default;
162 domain_error& operator=(domain_error&&) = default;
163#endif
164 virtual ~domain_error() _GLIBCXX_NOTHROW;
165 };
166
167 /** Thrown to report invalid arguments to functions. */
168 class invalid_argument : public logic_error
169 {
170 public:
171 explicit invalid_argument(const string& __arg) _GLIBCXX_TXN_SAFE;
172#if __cplusplus >= 201103L
173 explicit invalid_argument(const char*) _GLIBCXX_TXN_SAFE;
174 invalid_argument(const invalid_argument&) = default;
175 invalid_argument& operator=(const invalid_argument&) = default;
176 invalid_argument(invalid_argument&&) = default;
177 invalid_argument& operator=(invalid_argument&&) = default;
178#endif
179 virtual ~invalid_argument() _GLIBCXX_NOTHROW;
180 };
181
182 /** Thrown when an object is constructed that would exceed its maximum
183 * permitted size (e.g., a basic_string instance). */
184 class length_error : public logic_error
185 {
186 public:
187 explicit length_error(const string& __arg) _GLIBCXX_TXN_SAFE;
188#if __cplusplus >= 201103L
189 explicit length_error(const char*) _GLIBCXX_TXN_SAFE;
190 length_error(const length_error&) = default;
191 length_error& operator=(const length_error&) = default;
192 length_error(length_error&&) = default;
193 length_error& operator=(length_error&&) = default;
194#endif
195 virtual ~length_error() _GLIBCXX_NOTHROW;
196 };
197
198 /** This represents an argument whose value is not within the expected
199 * range (e.g., boundary checks in basic_string). */
200 class out_of_range : public logic_error
201 {
202 public:
203 explicit out_of_range(const string& __arg) _GLIBCXX_TXN_SAFE;
204#if __cplusplus >= 201103L
205 explicit out_of_range(const char*) _GLIBCXX_TXN_SAFE;
206 out_of_range(const out_of_range&) = default;
207 out_of_range& operator=(const out_of_range&) = default;
208 out_of_range(out_of_range&&) = default;
209 out_of_range& operator=(out_of_range&&) = default;
210#endif
211 virtual ~out_of_range() _GLIBCXX_NOTHROW;
212 };
213
214 /** Runtime errors represent problems outside the scope of a program;
215 * they cannot be easily predicted and can generally only be caught as
216 * the program executes.
217 * @brief One of two subclasses of exception.
218 */
219 class runtime_error : public exception
220 {
221 __cow_string _M_msg;
222
223 public:
224 /** Takes a character string describing the error. */
225 explicit
226 runtime_error(const string& __arg) _GLIBCXX_TXN_SAFE;
227
228#if __cplusplus >= 201103L
229 explicit
230 runtime_error(const char*) _GLIBCXX_TXN_SAFE;
231
232 runtime_error(runtime_error&&) noexcept;
233 runtime_error& operator=(runtime_error&&) noexcept;
234#endif
235
236#if _GLIBCXX_USE_CXX11_ABI || _GLIBCXX_DEFINE_STDEXCEPT_COPY_OPS
237 runtime_error(const runtime_error&) _GLIBCXX_NOTHROW;
238 runtime_error& operator=(const runtime_error&) _GLIBCXX_NOTHROW;
239#elif __cplusplus >= 201103L
240 runtime_error(const runtime_error&) = default;
241 runtime_error& operator=(const runtime_error&) = default;
242#endif
243
244 virtual ~runtime_error() _GLIBCXX_TXN_SAFE_DYN _GLIBCXX_NOTHROW;
245
246 /** Returns a C-style character string describing the general cause of
247 * the current error (the same string passed to the ctor). */
248 virtual const char*
249 what() const _GLIBCXX_TXN_SAFE_DYN _GLIBCXX_NOTHROW;
250
251# ifdef _GLIBCXX_TM_TS_INTERNAL
252 friend void*
253 ::_txnal_runtime_error_get_msg(void* e);
254# endif
255 };
256
257 /** Thrown to indicate range errors in internal computations. */
258 class range_error : public runtime_error
259 {
260 public:
261 explicit range_error(const string& __arg) _GLIBCXX_TXN_SAFE;
262#if __cplusplus >= 201103L
263 explicit range_error(const char*) _GLIBCXX_TXN_SAFE;
264 range_error(const range_error&) = default;
265 range_error& operator=(const range_error&) = default;
266 range_error(range_error&&) = default;
267 range_error& operator=(range_error&&) = default;
268#endif
269 virtual ~range_error() _GLIBCXX_NOTHROW;
270 };
271
272 /** Thrown to indicate arithmetic overflow. */
273 class overflow_error : public runtime_error
274 {
275 public:
276 explicit overflow_error(const string& __arg) _GLIBCXX_TXN_SAFE;
277#if __cplusplus >= 201103L
278 explicit overflow_error(const char*) _GLIBCXX_TXN_SAFE;
279 overflow_error(const overflow_error&) = default;
280 overflow_error& operator=(const overflow_error&) = default;
281 overflow_error(overflow_error&&) = default;
282 overflow_error& operator=(overflow_error&&) = default;
283#endif
284 virtual ~overflow_error() _GLIBCXX_NOTHROW;
285 };
286
287 /** Thrown to indicate arithmetic underflow. */
288 class underflow_error : public runtime_error
289 {
290 public:
291 explicit underflow_error(const string& __arg) _GLIBCXX_TXN_SAFE;
292#if __cplusplus >= 201103L
293 explicit underflow_error(const char*) _GLIBCXX_TXN_SAFE;
294 underflow_error(const underflow_error&) = default;
295 underflow_error& operator=(const underflow_error&) = default;
296 underflow_error(underflow_error&&) = default;
297 underflow_error& operator=(underflow_error&&) = default;
298#endif
299 virtual ~underflow_error() _GLIBCXX_NOTHROW;
300 };
301
302 /// @} group exceptions
303
304_GLIBCXX_END_NAMESPACE_VERSION
305} // namespace
306
307#endif /* _GLIBCXX_STDEXCEPT */
308