Coverage Report

Created: 2020-02-15 09:57

/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
    virtual ~domain_error() _NOEXCEPT;
133
#endif
134
};
135
136
class _LIBCPP_EXCEPTION_ABI invalid_argument
137
    : public logic_error
138
{
139
public:
140
0
    _LIBCPP_INLINE_VISIBILITY explicit invalid_argument(const string& __s) : logic_error(__s) {}
141
0
    _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
148
class _LIBCPP_EXCEPTION_ABI length_error
149
    : public logic_error
150
{
151
public:
152
0
    _LIBCPP_INLINE_VISIBILITY explicit length_error(const string& __s) : logic_error(__s) {}
153
0
    _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
159
class _LIBCPP_EXCEPTION_ABI out_of_range
160
    : public logic_error
161
{
162
public:
163
0
    _LIBCPP_INLINE_VISIBILITY explicit out_of_range(const string& __s) : logic_error(__s) {}
164
0
    _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
171
class _LIBCPP_EXCEPTION_ABI range_error
172
    : public runtime_error
173
{
174
public:
175
0
    _LIBCPP_INLINE_VISIBILITY explicit range_error(const string& __s) : runtime_error(__s) {}
176
0
    _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
183
class _LIBCPP_EXCEPTION_ABI overflow_error
184
    : public runtime_error
185
{
186
public:
187
0
    _LIBCPP_INLINE_VISIBILITY explicit overflow_error(const string& __s) : runtime_error(__s) {}
188
0
    _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
195
class _LIBCPP_EXCEPTION_ABI underflow_error
196
    : public runtime_error
197
{
198
public:
199
0
    _LIBCPP_INLINE_VISIBILITY explicit underflow_error(const string& __s) : runtime_error(__s) {}
200
0
    _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
215
void __throw_logic_error(const char*__msg)
216
0
{
217
0
#ifndef _LIBCPP_NO_EXCEPTIONS
218
0
    throw logic_error(__msg);
219
0
#else
220
0
    ((void)__msg);
221
0
    _VSTD::abort();
222
0
#endif
223
0
}
224
225
_LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
226
void __throw_domain_error(const char*__msg)
227
0
{
228
0
#ifndef _LIBCPP_NO_EXCEPTIONS
229
0
    throw domain_error(__msg);
230
0
#else
231
0
    ((void)__msg);
232
0
    _VSTD::abort();
233
0
#endif
234
0
}
235
236
_LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
237
void __throw_invalid_argument(const char*__msg)
238
0
{
239
0
#ifndef _LIBCPP_NO_EXCEPTIONS
240
0
    throw invalid_argument(__msg);
241
0
#else
242
0
    ((void)__msg);
243
0
    _VSTD::abort();
244
0
#endif
245
0
}
246
247
_LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
248
void __throw_length_error(const char*__msg)
249
0
{
250
0
#ifndef _LIBCPP_NO_EXCEPTIONS
251
0
    throw length_error(__msg);
252
#else
253
    ((void)__msg);
254
    _VSTD::abort();
255
#endif
256
}
257
258
_LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
259
void __throw_out_of_range(const char*__msg)
260
0
{
261
0
#ifndef _LIBCPP_NO_EXCEPTIONS
262
0
    throw out_of_range(__msg);
263
#else
264
    ((void)__msg);
265
    _VSTD::abort();
266
#endif
267
}
268
269
_LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
270
void __throw_range_error(const char*__msg)
271
0
{
272
0
#ifndef _LIBCPP_NO_EXCEPTIONS
273
0
    throw range_error(__msg);
274
0
#else
275
0
    ((void)__msg);
276
0
    _VSTD::abort();
277
0
#endif
278
0
}
279
280
_LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
281
void __throw_overflow_error(const char*__msg)
282
0
{
283
0
#ifndef _LIBCPP_NO_EXCEPTIONS
284
0
    throw overflow_error(__msg);
285
#else
286
    ((void)__msg);
287
    _VSTD::abort();
288
#endif
289
}
290
291
_LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
292
void __throw_underflow_error(const char*__msg)
293
0
{
294
0
#ifndef _LIBCPP_NO_EXCEPTIONS
295
0
    throw underflow_error(__msg);
296
0
#else
297
0
    ((void)__msg);
298
0
    _VSTD::abort();
299
0
#endif
300
0
}
301
302
_LIBCPP_END_NAMESPACE_STD
303
304
#endif  // _LIBCPP_STDEXCEPT