Coverage Report

Created: 2020-03-28 08:29

/Users/buildslave/jenkins/workspace/coverage/llvm-project/libcxx/include/stdexcept
Line
Count
Source (jump to first uncovered line)
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
16
namespace std
17
{
18
19
class logic_error;
20
    class domain_error;
21
    class invalid_argument;
22
    class length_error;
23
    class out_of_range;
24
class runtime_error;
25
    class range_error;
26
    class overflow_error;
27
    class underflow_error;
28
29
for each class xxx_error:
30
31
class xxx_error : public exception // at least indirectly
32
{
33
public:
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
58
class _LIBCPP_HIDDEN __libcpp_refstring
59
{
60
    const char* __imp_;
61
62
    bool __uses_refcount() const;
63
public:
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
0
    const char* c_str() const _NOEXCEPT {return __imp_;}
70
};
71
#endif // !_LIBCPP_ABI_VCRUNTIME
72
73
_LIBCPP_END_NAMESPACE_STD
74
75
namespace std  // purposefully not using versioning namespace
76
{
77
78
class _LIBCPP_EXCEPTION_ABI logic_error
79
    : public exception
80
{
81
#ifndef _LIBCPP_ABI_VCRUNTIME
82
private:
83
    _VSTD::__libcpp_refstring __imp_;
84
public:
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
95
public:
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
101
class _LIBCPP_EXCEPTION_ABI runtime_error
102
    : public exception
103
{
104
#ifndef _LIBCPP_ABI_VCRUNTIME
105
private:
106
    _VSTD::__libcpp_refstring __imp_;
107
public:
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
118
public:
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
124
class _LIBCPP_EXCEPTION_ABI domain_error
125
    : public logic_error
126
{
127
public:
128
0
    _LIBCPP_INLINE_VISIBILITY explicit domain_error(const string& __s) : logic_error(__s) {}
129
0
    _LIBCPP_INLINE_VISIBILITY explicit domain_error(const char* __s)   : logic_error(__s) {}
130
131
#ifndef _LIBCPP_ABI_VCRUNTIME
132
    domain_error(const domain_error&) _NOEXCEPT = default;
133
    virtual ~domain_error() _NOEXCEPT;
134
#endif
135
};
136
137
class _LIBCPP_EXCEPTION_ABI invalid_argument
138
    : public logic_error
139
{
140
public:
141
0
    _LIBCPP_INLINE_VISIBILITY explicit invalid_argument(const string& __s) : logic_error(__s) {}
142
0
    _LIBCPP_INLINE_VISIBILITY explicit invalid_argument(const char* __s)   : logic_error(__s) {}
143
144
#ifndef _LIBCPP_ABI_VCRUNTIME
145
    invalid_argument(const invalid_argument&) _NOEXCEPT = default;
146
    virtual ~invalid_argument() _NOEXCEPT;
147
#endif
148
};
149
150
class _LIBCPP_EXCEPTION_ABI length_error
151
    : public logic_error
152
{
153
public:
154
0
    _LIBCPP_INLINE_VISIBILITY explicit length_error(const string& __s) : logic_error(__s) {}
155
0
    _LIBCPP_INLINE_VISIBILITY explicit length_error(const char* __s)   : logic_error(__s) {}
156
#ifndef _LIBCPP_ABI_VCRUNTIME
157
    length_error(const length_error&) _NOEXCEPT = default;
158
    virtual ~length_error() _NOEXCEPT;
159
#endif
160
};
161
162
class _LIBCPP_EXCEPTION_ABI out_of_range
163
    : public logic_error
164
{
165
public:
166
0
    _LIBCPP_INLINE_VISIBILITY explicit out_of_range(const string& __s) : logic_error(__s) {}
167
0
    _LIBCPP_INLINE_VISIBILITY explicit out_of_range(const char* __s)   : logic_error(__s) {}
168
169
#ifndef _LIBCPP_ABI_VCRUNTIME
170
    out_of_range(const out_of_range&) _NOEXCEPT = default;
171
    virtual ~out_of_range() _NOEXCEPT;
172
#endif
173
};
174
175
class _LIBCPP_EXCEPTION_ABI range_error
176
    : public runtime_error
177
{
178
public:
179
0
    _LIBCPP_INLINE_VISIBILITY explicit range_error(const string& __s) : runtime_error(__s) {}
180
0
    _LIBCPP_INLINE_VISIBILITY explicit range_error(const char* __s)   : runtime_error(__s) {}
181
182
#ifndef _LIBCPP_ABI_VCRUNTIME
183
    range_error(const range_error&) _NOEXCEPT = default;
184
    virtual ~range_error() _NOEXCEPT;
185
#endif
186
};
187
188
class _LIBCPP_EXCEPTION_ABI overflow_error
189
    : public runtime_error
190
{
191
public:
192
0
    _LIBCPP_INLINE_VISIBILITY explicit overflow_error(const string& __s) : runtime_error(__s) {}
193
0
    _LIBCPP_INLINE_VISIBILITY explicit overflow_error(const char* __s)   : runtime_error(__s) {}
194
195
#ifndef _LIBCPP_ABI_VCRUNTIME
196
    overflow_error(const overflow_error&) _NOEXCEPT = default;
197
    virtual ~overflow_error() _NOEXCEPT;
198
#endif
199
};
200
201
class _LIBCPP_EXCEPTION_ABI underflow_error
202
    : public runtime_error
203
{
204
public:
205
0
    _LIBCPP_INLINE_VISIBILITY explicit underflow_error(const string& __s) : runtime_error(__s) {}
206
0
    _LIBCPP_INLINE_VISIBILITY explicit underflow_error(const char* __s)   : runtime_error(__s) {}
207
208
#ifndef _LIBCPP_ABI_VCRUNTIME
209
    underflow_error(const underflow_error&) _NOEXCEPT = default;
210
    virtual ~underflow_error() _NOEXCEPT;
211
#endif
212
};
213
214
}  // std
215
216
_LIBCPP_BEGIN_NAMESPACE_STD
217
218
// in the dylib
219
_LIBCPP_NORETURN _LIBCPP_FUNC_VIS void __throw_runtime_error(const char*);
220
221
_LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
222
void __throw_logic_error(const char*__msg)
223
0
{
224
0
#ifndef _LIBCPP_NO_EXCEPTIONS
225
0
    throw logic_error(__msg);
226
0
#else
227
0
    ((void)__msg);
228
0
    _VSTD::abort();
229
0
#endif
230
0
}
231
232
_LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
233
void __throw_domain_error(const char*__msg)
234
0
{
235
0
#ifndef _LIBCPP_NO_EXCEPTIONS
236
0
    throw domain_error(__msg);
237
0
#else
238
0
    ((void)__msg);
239
0
    _VSTD::abort();
240
0
#endif
241
0
}
242
243
_LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
244
void __throw_invalid_argument(const char*__msg)
245
0
{
246
0
#ifndef _LIBCPP_NO_EXCEPTIONS
247
0
    throw invalid_argument(__msg);
248
0
#else
249
0
    ((void)__msg);
250
0
    _VSTD::abort();
251
0
#endif
252
0
}
253
254
_LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
255
void __throw_length_error(const char*__msg)
256
0
{
257
0
#ifndef _LIBCPP_NO_EXCEPTIONS
258
0
    throw length_error(__msg);
259
#else
260
    ((void)__msg);
261
    _VSTD::abort();
262
#endif
263
}
264
265
_LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
266
void __throw_out_of_range(const char*__msg)
267
0
{
268
0
#ifndef _LIBCPP_NO_EXCEPTIONS
269
0
    throw out_of_range(__msg);
270
#else
271
    ((void)__msg);
272
    _VSTD::abort();
273
#endif
274
}
275
276
_LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
277
void __throw_range_error(const char*__msg)
278
0
{
279
0
#ifndef _LIBCPP_NO_EXCEPTIONS
280
0
    throw range_error(__msg);
281
0
#else
282
0
    ((void)__msg);
283
0
    _VSTD::abort();
284
0
#endif
285
0
}
286
287
_LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
288
void __throw_overflow_error(const char*__msg)
289
0
{
290
0
#ifndef _LIBCPP_NO_EXCEPTIONS
291
0
    throw overflow_error(__msg);
292
#else
293
    ((void)__msg);
294
    _VSTD::abort();
295
#endif
296
}
297
298
_LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
299
void __throw_underflow_error(const char*__msg)
300
0
{
301
0
#ifndef _LIBCPP_NO_EXCEPTIONS
302
0
    throw underflow_error(__msg);
303
0
#else
304
0
    ((void)__msg);
305
0
    _VSTD::abort();
306
0
#endif
307
0
}
308
309
_LIBCPP_END_NAMESPACE_STD
310
311
#endif  // _LIBCPP_STDEXCEPT