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