1// -*- C++ -*-
2//===--------------------------- stdexcept --------------------------------===//
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;
20 class domain_error;
21 class invalid_argument;
22 class length_error;
23 class out_of_range;
24class runtime_error;
25 class range_error;
26 class overflow_error;
27 class 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#include <__config>
45#include <exception>
46#include <iosfwd> // for string forward decl
47#ifdef _LIBCPP_NO_EXCEPTIONS
48#include <cstdlib>
49#endif
50
51#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
52#pragma GCC system_header
53#endif
54
55_LIBCPP_BEGIN_NAMESPACE_STD
56
57#ifndef _LIBCPP_ABI_VCRUNTIME
58class _LIBCPP_HIDDEN __libcpp_refstring
59{
60 const char* __imp_;
61
62 bool __uses_refcount() const;
63public:
64 explicit __libcpp_refstring(const char* __msg);
65 __libcpp_refstring(const __libcpp_refstring& __s) _NOEXCEPT;
66 __libcpp_refstring& operator=(const __libcpp_refstring& __s) _NOEXCEPT;
67 ~__libcpp_refstring();
68
69 const char* c_str() const _NOEXCEPT {return __imp_;}
70};
71#endif // !_LIBCPP_ABI_VCRUNTIME
72
73_LIBCPP_END_NAMESPACE_STD
74
75namespace std // purposefully not using versioning namespace
76{
77
78class _LIBCPP_EXCEPTION_ABI logic_error
79 : public exception
80{
81#ifndef _LIBCPP_ABI_VCRUNTIME
82private:
83 _VSTD::__libcpp_refstring __imp_;
84public:
85 explicit logic_error(const string&);
86 explicit logic_error(const char*);
87
88 logic_error(const logic_error&) _NOEXCEPT;
89 logic_error& operator=(const logic_error&) _NOEXCEPT;
90
91 virtual ~logic_error() _NOEXCEPT;
92
93 virtual const char* what() const _NOEXCEPT;
94#else
95public:
96 explicit logic_error(const _VSTD::string&); // Symbol uses versioned std::string
97 _LIBCPP_INLINE_VISIBILITY explicit logic_error(const char* __s) : exception(__s) {}
98#endif
99};
100
101class _LIBCPP_EXCEPTION_ABI runtime_error
102 : public exception
103{
104#ifndef _LIBCPP_ABI_VCRUNTIME
105private:
106 _VSTD::__libcpp_refstring __imp_;
107public:
108 explicit runtime_error(const string&);
109 explicit runtime_error(const char*);
110
111 runtime_error(const runtime_error&) _NOEXCEPT;
112 runtime_error& operator=(const runtime_error&) _NOEXCEPT;
113
114 virtual ~runtime_error() _NOEXCEPT;
115
116 virtual const char* what() const _NOEXCEPT;
117#else
118public:
119 explicit runtime_error(const _VSTD::string&); // Symbol uses versioned std::string
120 _LIBCPP_INLINE_VISIBILITY explicit runtime_error(const char* __s) : exception(__s) {}
121#endif // _LIBCPP_ABI_VCRUNTIME
122};
123
124class _LIBCPP_EXCEPTION_ABI domain_error
125 : public logic_error
126{
127public:
128 _LIBCPP_INLINE_VISIBILITY explicit domain_error(const string& __s) : logic_error(__s) {}
129 _LIBCPP_INLINE_VISIBILITY explicit domain_error(const char* __s) : logic_error(__s) {}
130
131#ifndef _LIBCPP_ABI_VCRUNTIME
132 virtual ~domain_error() _NOEXCEPT;
133#endif
134};
135
136class _LIBCPP_EXCEPTION_ABI invalid_argument
137 : public logic_error
138{
139public:
140 _LIBCPP_INLINE_VISIBILITY explicit invalid_argument(const string& __s) : logic_error(__s) {}
141 _LIBCPP_INLINE_VISIBILITY explicit invalid_argument(const char* __s) : logic_error(__s) {}
142
143#ifndef _LIBCPP_ABI_VCRUNTIME
144 virtual ~invalid_argument() _NOEXCEPT;
145#endif
146};
147
148class _LIBCPP_EXCEPTION_ABI length_error
149 : public logic_error
150{
151public:
152 _LIBCPP_INLINE_VISIBILITY explicit length_error(const string& __s) : logic_error(__s) {}
153 _LIBCPP_INLINE_VISIBILITY explicit length_error(const char* __s) : logic_error(__s) {}
154#ifndef _LIBCPP_ABI_VCRUNTIME
155 virtual ~length_error() _NOEXCEPT;
156#endif
157};
158
159class _LIBCPP_EXCEPTION_ABI out_of_range
160 : public logic_error
161{
162public:
163 _LIBCPP_INLINE_VISIBILITY explicit out_of_range(const string& __s) : logic_error(__s) {}
164 _LIBCPP_INLINE_VISIBILITY explicit out_of_range(const char* __s) : logic_error(__s) {}
165
166#ifndef _LIBCPP_ABI_VCRUNTIME
167 virtual ~out_of_range() _NOEXCEPT;
168#endif
169};
170
171class _LIBCPP_EXCEPTION_ABI range_error
172 : public runtime_error
173{
174public:
175 _LIBCPP_INLINE_VISIBILITY explicit range_error(const string& __s) : runtime_error(__s) {}
176 _LIBCPP_INLINE_VISIBILITY explicit range_error(const char* __s) : runtime_error(__s) {}
177
178#ifndef _LIBCPP_ABI_VCRUNTIME
179 virtual ~range_error() _NOEXCEPT;
180#endif
181};
182
183class _LIBCPP_EXCEPTION_ABI overflow_error
184 : public runtime_error
185{
186public:
187 _LIBCPP_INLINE_VISIBILITY explicit overflow_error(const string& __s) : runtime_error(__s) {}
188 _LIBCPP_INLINE_VISIBILITY explicit overflow_error(const char* __s) : runtime_error(__s) {}
189
190#ifndef _LIBCPP_ABI_VCRUNTIME
191 virtual ~overflow_error() _NOEXCEPT;
192#endif
193};
194
195class _LIBCPP_EXCEPTION_ABI underflow_error
196 : public runtime_error
197{
198public:
199 _LIBCPP_INLINE_VISIBILITY explicit underflow_error(const string& __s) : runtime_error(__s) {}
200 _LIBCPP_INLINE_VISIBILITY explicit underflow_error(const char* __s) : runtime_error(__s) {}
201
202#ifndef _LIBCPP_ABI_VCRUNTIME
203 virtual ~underflow_error() _NOEXCEPT;
204#endif
205};
206
207} // std
208
209_LIBCPP_BEGIN_NAMESPACE_STD
210
211// in the dylib
212_LIBCPP_NORETURN _LIBCPP_FUNC_VIS void __throw_runtime_error(const char*);
213
214_LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
215void __throw_logic_error(const char*__msg)
216{
217#ifndef _LIBCPP_NO_EXCEPTIONS
218 throw logic_error(__msg);
219#else
220 ((void)__msg);
221 _VSTD::abort();
222#endif
223}
224
225_LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
226void __throw_domain_error(const char*__msg)
227{
228#ifndef _LIBCPP_NO_EXCEPTIONS
229 throw domain_error(__msg);
230#else
231 ((void)__msg);
232 _VSTD::abort();
233#endif
234}
235
236_LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
237void __throw_invalid_argument(const char*__msg)
238{
239#ifndef _LIBCPP_NO_EXCEPTIONS
240 throw invalid_argument(__msg);
241#else
242 ((void)__msg);
243 _VSTD::abort();
244#endif
245}
246
247_LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
248void __throw_length_error(const char*__msg)
249{
250#ifndef _LIBCPP_NO_EXCEPTIONS
251 throw length_error(__msg);
252#else
253 ((void)__msg);
254 _VSTD::abort();
255#endif
256}
257
258_LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
259void __throw_out_of_range(const char*__msg)
260{
261#ifndef _LIBCPP_NO_EXCEPTIONS
262 throw out_of_range(__msg);
263#else
264 ((void)__msg);
265 _VSTD::abort();
266#endif
267}
268
269_LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
270void __throw_range_error(const char*__msg)
271{
272#ifndef _LIBCPP_NO_EXCEPTIONS
273 throw range_error(__msg);
274#else
275 ((void)__msg);
276 _VSTD::abort();
277#endif
278}
279
280_LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
281void __throw_overflow_error(const char*__msg)
282{
283#ifndef _LIBCPP_NO_EXCEPTIONS
284 throw overflow_error(__msg);
285#else
286 ((void)__msg);
287 _VSTD::abort();
288#endif
289}
290
291_LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
292void __throw_underflow_error(const char*__msg)
293{
294#ifndef _LIBCPP_NO_EXCEPTIONS
295 throw underflow_error(__msg);
296#else
297 ((void)__msg);
298 _VSTD::abort();
299#endif
300}
301
302_LIBCPP_END_NAMESPACE_STD
303
304#endif // _LIBCPP_STDEXCEPT
305