Line data    Source code

       1             : // Standard exception classes  -*- C++ -*-
       2             : 
       3             : // Copyright (C) 2001-2019 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             : 
      41             : namespace 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           0 :     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           0 :     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 */