master
1// -*- C++ -*-
2//===----------------------------------------------------------------------===//
3//
4// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
5// See https://llvm.org/LICENSE.txt for license information.
6// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
7//
8//===----------------------------------------------------------------------===//
9
10#ifndef _LIBCPP_STDEXCEPT
11#define _LIBCPP_STDEXCEPT
12
13/*
14 stdexcept synopsis
15
16namespace std
17{
18
19class logic_error;
20class domain_error;
21class invalid_argument;
22class length_error;
23class out_of_range;
24class runtime_error;
25class range_error;
26class overflow_error;
27class underflow_error;
28
29for each class xxx_error:
30
31class xxx_error : public exception // at least indirectly
32{
33public:
34 explicit xxx_error(const string& what_arg);
35 explicit xxx_error(const char* what_arg);
36
37 virtual const char* what() const noexcept // returns what_arg
38};
39
40} // std
41
42*/
43
44#if __cplusplus < 201103L && defined(_LIBCPP_USE_FROZEN_CXX03_HEADERS)
45# include <__cxx03/stdexcept>
46#else
47# include <__config>
48# include <__exception/exception.h>
49# include <__fwd/string.h>
50# include <__verbose_abort>
51
52# if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
53# pragma GCC system_header
54# endif
55
56_LIBCPP_BEGIN_NAMESPACE_STD
57
58# ifndef _LIBCPP_ABI_VCRUNTIME
59class _LIBCPP_HIDDEN __libcpp_refstring {
60 const char* __imp_;
61
62 bool __uses_refcount() const;
63
64public:
65 explicit __libcpp_refstring(const char* __msg);
66 __libcpp_refstring(const __libcpp_refstring& __s) _NOEXCEPT;
67 __libcpp_refstring& operator=(const __libcpp_refstring& __s) _NOEXCEPT;
68 ~__libcpp_refstring();
69
70 _LIBCPP_HIDE_FROM_ABI const char* c_str() const _NOEXCEPT { return __imp_; }
71};
72# endif // !_LIBCPP_ABI_VCRUNTIME
73
74_LIBCPP_END_NAMESPACE_STD
75
76namespace std // purposefully not using versioning namespace
77{
78
79class _LIBCPP_EXPORTED_FROM_ABI logic_error : public exception {
80# ifndef _LIBCPP_ABI_VCRUNTIME
81
82private:
83 std::__libcpp_refstring __imp_;
84
85public:
86 explicit logic_error(const string&);
87 explicit logic_error(const char*);
88
89 logic_error(const logic_error&) _NOEXCEPT;
90 logic_error& operator=(const logic_error&) _NOEXCEPT;
91
92 ~logic_error() _NOEXCEPT override;
93
94 const char* what() const _NOEXCEPT override;
95# else
96
97public:
98 explicit logic_error(const std::string&); // Symbol uses versioned std::string
99 _LIBCPP_HIDE_FROM_ABI explicit logic_error(const char* __s) : exception(__s) {}
100# endif
101};
102
103class _LIBCPP_EXPORTED_FROM_ABI runtime_error : public exception {
104# ifndef _LIBCPP_ABI_VCRUNTIME
105
106private:
107 std::__libcpp_refstring __imp_;
108
109public:
110 explicit runtime_error(const string&);
111 explicit runtime_error(const char*);
112
113 runtime_error(const runtime_error&) _NOEXCEPT;
114 runtime_error& operator=(const runtime_error&) _NOEXCEPT;
115
116 ~runtime_error() _NOEXCEPT override;
117
118 const char* what() const _NOEXCEPT override;
119# else
120
121public:
122 explicit runtime_error(const std::string&); // Symbol uses versioned std::string
123 _LIBCPP_HIDE_FROM_ABI explicit runtime_error(const char* __s) : exception(__s) {}
124# endif // _LIBCPP_ABI_VCRUNTIME
125};
126
127class _LIBCPP_EXPORTED_FROM_ABI domain_error : public logic_error {
128public:
129 _LIBCPP_HIDE_FROM_ABI explicit domain_error(const string& __s) : logic_error(__s) {}
130 _LIBCPP_HIDE_FROM_ABI explicit domain_error(const char* __s) : logic_error(__s) {}
131
132# ifndef _LIBCPP_ABI_VCRUNTIME
133 _LIBCPP_HIDE_FROM_ABI domain_error(const domain_error&) _NOEXCEPT = default;
134 _LIBCPP_HIDE_FROM_ABI domain_error& operator=(const domain_error&) _NOEXCEPT = default;
135 ~domain_error() _NOEXCEPT override;
136# endif
137};
138
139class _LIBCPP_EXPORTED_FROM_ABI invalid_argument : public logic_error {
140public:
141 _LIBCPP_HIDE_FROM_ABI explicit invalid_argument(const string& __s) : logic_error(__s) {}
142 _LIBCPP_HIDE_FROM_ABI explicit invalid_argument(const char* __s) : logic_error(__s) {}
143
144# ifndef _LIBCPP_ABI_VCRUNTIME
145 _LIBCPP_HIDE_FROM_ABI invalid_argument(const invalid_argument&) _NOEXCEPT = default;
146 _LIBCPP_HIDE_FROM_ABI invalid_argument& operator=(const invalid_argument&) _NOEXCEPT = default;
147 ~invalid_argument() _NOEXCEPT override;
148# endif
149};
150
151class _LIBCPP_EXPORTED_FROM_ABI length_error : public logic_error {
152public:
153 _LIBCPP_HIDE_FROM_ABI explicit length_error(const string& __s) : logic_error(__s) {}
154 _LIBCPP_HIDE_FROM_ABI explicit length_error(const char* __s) : logic_error(__s) {}
155# ifndef _LIBCPP_ABI_VCRUNTIME
156 _LIBCPP_HIDE_FROM_ABI length_error(const length_error&) _NOEXCEPT = default;
157 _LIBCPP_HIDE_FROM_ABI length_error& operator=(const length_error&) _NOEXCEPT = default;
158 ~length_error() _NOEXCEPT override;
159# endif
160};
161
162class _LIBCPP_EXPORTED_FROM_ABI out_of_range : public logic_error {
163public:
164 _LIBCPP_HIDE_FROM_ABI explicit out_of_range(const string& __s) : logic_error(__s) {}
165 _LIBCPP_HIDE_FROM_ABI explicit out_of_range(const char* __s) : logic_error(__s) {}
166
167# ifndef _LIBCPP_ABI_VCRUNTIME
168 _LIBCPP_HIDE_FROM_ABI out_of_range(const out_of_range&) _NOEXCEPT = default;
169 _LIBCPP_HIDE_FROM_ABI out_of_range& operator=(const out_of_range&) _NOEXCEPT = default;
170 ~out_of_range() _NOEXCEPT override;
171# endif
172};
173
174class _LIBCPP_EXPORTED_FROM_ABI range_error : public runtime_error {
175public:
176 _LIBCPP_HIDE_FROM_ABI explicit range_error(const string& __s) : runtime_error(__s) {}
177 _LIBCPP_HIDE_FROM_ABI explicit range_error(const char* __s) : runtime_error(__s) {}
178
179# ifndef _LIBCPP_ABI_VCRUNTIME
180 _LIBCPP_HIDE_FROM_ABI range_error(const range_error&) _NOEXCEPT = default;
181 _LIBCPP_HIDE_FROM_ABI range_error& operator=(const range_error&) _NOEXCEPT = default;
182 ~range_error() _NOEXCEPT override;
183# endif
184};
185
186class _LIBCPP_EXPORTED_FROM_ABI overflow_error : public runtime_error {
187public:
188 _LIBCPP_HIDE_FROM_ABI explicit overflow_error(const string& __s) : runtime_error(__s) {}
189 _LIBCPP_HIDE_FROM_ABI explicit overflow_error(const char* __s) : runtime_error(__s) {}
190
191# ifndef _LIBCPP_ABI_VCRUNTIME
192 _LIBCPP_HIDE_FROM_ABI overflow_error(const overflow_error&) _NOEXCEPT = default;
193 _LIBCPP_HIDE_FROM_ABI overflow_error& operator=(const overflow_error&) _NOEXCEPT = default;
194 ~overflow_error() _NOEXCEPT override;
195# endif
196};
197
198class _LIBCPP_EXPORTED_FROM_ABI underflow_error : public runtime_error {
199public:
200 _LIBCPP_HIDE_FROM_ABI explicit underflow_error(const string& __s) : runtime_error(__s) {}
201 _LIBCPP_HIDE_FROM_ABI explicit underflow_error(const char* __s) : runtime_error(__s) {}
202
203# ifndef _LIBCPP_ABI_VCRUNTIME
204 _LIBCPP_HIDE_FROM_ABI underflow_error(const underflow_error&) _NOEXCEPT = default;
205 _LIBCPP_HIDE_FROM_ABI underflow_error& operator=(const underflow_error&) _NOEXCEPT = default;
206 ~underflow_error() _NOEXCEPT override;
207# endif
208};
209
210} // namespace std
211
212_LIBCPP_BEGIN_NAMESPACE_STD
213
214// in the dylib
215[[__noreturn__]] _LIBCPP_EXPORTED_FROM_ABI void __throw_runtime_error(const char*);
216
217[[__noreturn__]] inline _LIBCPP_HIDE_FROM_ABI void __throw_logic_error(const char* __msg) {
218# if _LIBCPP_HAS_EXCEPTIONS
219 throw logic_error(__msg);
220# else
221 _LIBCPP_VERBOSE_ABORT("logic_error was thrown in -fno-exceptions mode with message \"%s\"", __msg);
222# endif
223}
224
225[[__noreturn__]] inline _LIBCPP_HIDE_FROM_ABI void __throw_domain_error(const char* __msg) {
226# if _LIBCPP_HAS_EXCEPTIONS
227 throw domain_error(__msg);
228# else
229 _LIBCPP_VERBOSE_ABORT("domain_error was thrown in -fno-exceptions mode with message \"%s\"", __msg);
230# endif
231}
232
233[[__noreturn__]] inline _LIBCPP_HIDE_FROM_ABI void __throw_invalid_argument(const char* __msg) {
234# if _LIBCPP_HAS_EXCEPTIONS
235 throw invalid_argument(__msg);
236# else
237 _LIBCPP_VERBOSE_ABORT("invalid_argument was thrown in -fno-exceptions mode with message \"%s\"", __msg);
238# endif
239}
240
241[[__noreturn__]] inline _LIBCPP_HIDE_FROM_ABI void __throw_length_error(const char* __msg) {
242# if _LIBCPP_HAS_EXCEPTIONS
243 throw length_error(__msg);
244# else
245 _LIBCPP_VERBOSE_ABORT("length_error was thrown in -fno-exceptions mode with message \"%s\"", __msg);
246# endif
247}
248
249[[__noreturn__]] inline _LIBCPP_HIDE_FROM_ABI void __throw_out_of_range(const char* __msg) {
250# if _LIBCPP_HAS_EXCEPTIONS
251 throw out_of_range(__msg);
252# else
253 _LIBCPP_VERBOSE_ABORT("out_of_range was thrown in -fno-exceptions mode with message \"%s\"", __msg);
254# endif
255}
256
257[[__noreturn__]] inline _LIBCPP_HIDE_FROM_ABI void __throw_range_error(const char* __msg) {
258# if _LIBCPP_HAS_EXCEPTIONS
259 throw range_error(__msg);
260# else
261 _LIBCPP_VERBOSE_ABORT("range_error was thrown in -fno-exceptions mode with message \"%s\"", __msg);
262# endif
263}
264
265[[__noreturn__]] inline _LIBCPP_HIDE_FROM_ABI void __throw_overflow_error(const char* __msg) {
266# if _LIBCPP_HAS_EXCEPTIONS
267 throw overflow_error(__msg);
268# else
269 _LIBCPP_VERBOSE_ABORT("overflow_error was thrown in -fno-exceptions mode with message \"%s\"", __msg);
270# endif
271}
272
273[[__noreturn__]] inline _LIBCPP_HIDE_FROM_ABI void __throw_underflow_error(const char* __msg) {
274# if _LIBCPP_HAS_EXCEPTIONS
275 throw underflow_error(__msg);
276# else
277 _LIBCPP_VERBOSE_ABORT("underflow_error was thrown in -fno-exceptions mode with message \"%s\"", __msg);
278# endif
279}
280
281_LIBCPP_END_NAMESPACE_STD
282
283# if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
284# include <cstddef>
285# include <cstdlib>
286# include <exception>
287# include <iosfwd>
288# include <new>
289# endif
290#endif // __cplusplus < 201103L && defined(_LIBCPP_USE_FROZEN_CXX03_HEADERS)
291
292#endif // _LIBCPP_STDEXCEPT