1// Standard exception classes -*- C++ -*- 
2 
3// Copyright (C) 2001-2019 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