include/lightlibc++/exception.hpp

   1 /*
   2 Permission is granted to use, modify, and / or redistribute at will.
   3
   4 This includes removing authorship notices, re-use of code parts in
   5 other software (with or without giving credit), and / or creating a
   6 commercial product based on it.
   7
   8 This permission is not revocable by the author.
   9
  10 This software is provided as-is. Use it at your own risk. There is
  11 no warranty whatsoever, neither expressed nor implied, and by using
  12 this software you accept that the author(s) shall not be held liable
  13 for any loss of data, loss of service, or other damages, be they
  14 incidental or consequential. Your only option other than accepting
  15 this is not to use the software at all.
  16 */
  17 #ifndef _LIGHTLIBCPP_EXCEPTION_HPP
  18 #define _LIGHTLIBCPP_EXCEPTION_HPP
  19
  20
  21
  22 #include <lightlibc++/compiler.hpp>
  23
  24
  25
  26 namespace std
  27 {
  28   /** \addtogroup lightlibcpp_18_8 */
  29   /*@{*/
  30
  31 #ifndef _LIGHTLIBCPP_NO_EXCEPTIONS
  32
  33   /**
  34    *\english
  35    *  \brief Base class for exceptions thrown by the C++ Standard Library
  36    *
  37    *  18.8.1 Class exception
  38    *
  39    *  Base class for exceptions thrown by the C++ Standard Library
  40    *\endenglish
  41    *\german
  42    *  \brief Basisklasse der Ausnahmen, die von der C++ Standardbibliothek geworfen werden
  43    *
  44    *  18.8.1 Klasse exception
  45    *
  46    *  Basisklasse der Ausnahmen, die von der C++ Standardbibliothek geworfen werden
  47    *\endgerman
  48    */
  49   class exception
  50   {
  51     public:
  52       /**
  53        *\english
  54        *  Constructs an object of class exception.
  55        *\endenglish
  56        *\german
  57        *  Konstruiert ein Objekt der Klasse exception.
  58        *\endgerman */
  59       inline exception() throw()
  60       {
  61       }
  62
  63       /**
  64        *\english
  65        *  Copies an object of class exception.
  66        *  \param[in] x reference to the object to copy
  67        *\endenglish
  68        *\german
  69        *  Kopiert ein Objekt der Klasse exception.
  70        *  \param[in] x Referenz auf das zu kopierende Objekt
  71        *\endgerman */
  72       inline exception(const exception& x) throw()
  73       {
  74         (void)x;
  75       }
  76
  77       /**
  78        *\english
  79        *  Copies an object of class exception.
  80        *  \param[in] x reference to the object to copy
  81        *\endenglish
  82        *\german
  83        *  Kopiert ein Objekt der Klasse exception.
  84        *  \param[in] x Referenz auf das zu kopierende Objekt
  85        *\endgerman */
  86       inline exception& operator = (const exception& x) throw()
  87       {
  88         (void)x;
  89         return *this;
  90       }
  91
  92       /**
  93        *\english
  94        *  Destructs an object of class exception
  95        *\endenglish
  96        *\german
  97        *  Zerstört ein Objekt der Klasse exception
  98        *\endgerman */
  99       virtual ~exception() throw();
 100
 101       /**
 102        *\english
 103        *  User-friendly name of the class
 104        *  \return null-terminated character sequence
 105        *\endenglish
 106        *\german
 107        *  Benutzerfreundlicher Name der Klasse
 108        *  \return nullterminierte Zeichenkette
 109        *\endgerman
 110        */
 111       virtual const char* what() const throw();
 112   };
 113
 114 #endif
 115
 116   /*@}*/
 117
 118
 119
 120   /** \addtogroup lightlibcpp_18_8_2 */
 121   /*@{*/
 122
 123 #ifndef _LIGHTLIBCPP_NO_EXCEPTIONS
 124
 125   /**
 126    *\english
 127    *  \brief Class thrown by the runtime, when an exception-specification is
 128    *         violated
 129    *
 130    *  18.8.2.1 Class bad_exception
 131    *
 132    *  Class thrown by the runtime, when an exception-specification is violated
 133    *\endenglish
 134    *\german
 135    *  \brief Klasse die von der Laufzeit geworfen wird, wenn eine
 136    *         Ausnahmenspezifikation verletzt wurde
 137    *
 138    *  18.8.2.1 Klasse bad_exception
 139    *
 140    *  Klasse die von der Laufzeit geworfen wird, wenn eine
 141    *  Ausnahmenspezifikation verletzt wurde
 142    *\endgerman
 143    */
 144   class bad_exception : public std::exception
 145   {
 146     public:
 147       /**
 148        *\english
 149        *  Constructs an object of class bad_exception.
 150        *\endenglish
 151        *\german
 152        *  Konstruiert ein Objekt der Klasse bad_exception.
 153        *\endgerman */
 154       inline bad_exception() throw()
 155       {
 156       }
 157
 158       /**
 159        *\english
 160        *  Copies an object of class bad_exception.
 161        *  \param[in] x reference to the object to copy
 162        *\endenglish
 163        *\german
 164        *  Kopiert ein Objekt der Klasse bad_exception.
 165        *  \param[in] x Referenz auf das zu kopierende Objekt
 166        *\endgerman */
 167       inline bad_exception(const bad_exception& x) throw()
 168         : std::exception(x)
 169       {
 170       }
 171
 172       /**
 173        *\english
 174        *  Destructs an object of class bad_exception
 175        *\endenglish
 176        *\german
 177        *  Zerstört ein Objekt der Klasse bad_exception
 178        *\endgerman */
 179       virtual ~bad_exception() throw();
 180
 181       virtual const char* what() const throw();
 182   };
 183
 184 #endif
 185
 186   /**
 187    *\english
 188    *  18.8.2.2 Type unexpected_handler
 189    *
 190    *  The type of a handler function to be called by unexpected() when a
 191    *  function attempts to throw an exception not listed in its
 192    *  exception-speciﬁcation.
 193    *
 194    *  An unexpected_handler shall not return.
 195    *
 196    *  The default unexpected_handler calls terminate().
 197    *\endenglish
 198    *\german
 199    *  18.8.2.2 Typ unexpected_handler
 200    *
 201    *  Der Typ einer Handlerfunktion, welche von unexpected() aufgerufen wird,
 202    *  wenn eine Funktion eine Ausnahme, die nicht in ihrer
 203    *  Ausnahmenspezifikation angegeben ist, wirft.
 204    *
 205    *  Ein unexpected_handler darf die Kontrolle nicht an die aufrufende
 206    *  Funktion zurückgeben.
 207    *
 208    *  Der standardmäßig installierte unexpected_handler ruft terminate() auf.
 209    *\endgerman
 210    */
 211   typedef void (*unexpected_handler)() _LIGHTLIBCPP_NORETURN;
 212
 213   /**
 214    *  18.8.2.3 set_unexpected
 215    *
 216    *\english
 217    *  The unexpected_handler f becomes the new handler called by unexpected()
 218    *  \param[in] f a non-null pointer to the new unexpected_handler
 219    *  \return a pointer to the previous unexpected_handler
 220    *\endenglish
 221    *\german
 222    *  Der unexpected_handler f wird der neue Handler, der von unexpected()
 223    *  aufgerufen wird
 224    *  \param[in] f ein gültiger Zeiger auf einen unexpected_handler
 225    *  \return ein Zeiger auf den vorhergehende unexpected_handler
 226    *\endgerman
 227    */
 228   unexpected_handler set_unexpected(unexpected_handler f) throw();
 229
 230   /**
 231    *\english
 232    *  lightlibc++ extension
 233    *
 234    *  Get the current unexpected_handler
 235    *  \note This function is needed by the C++ exception handling ABI
 236    *  \return apointer to the current unexpected_handler
 237    *\endenglish
 238    *\german
 239    *  lightlibc++ Erweiterung
 240    *
 241    *  Gibt einen Zeiger auf momentan installierten unexpected_handler zurück
 242    *  \note Diese Funktion wird von der C++ Ausnahmebehandlungs-ABI benötigt
 243    *  \return ein Zeiger auf den momentan installierten unexpected_handler
 244    *\endgerman
 245    */
 246   unexpected_handler __get_unexpected();
 247
 248   /**
 249    *  18.8.2.4 unexpected
 250    *
 251    *\english
 252    *  Called by the implementation when a function exits via an exception not
 253    *  allowed by its exception-speciﬁcation. May also be called directly by the
 254    *  program.
 255    *
 256    *  Calls the calls the current unexpected_handler.
 257    *\endenglish
 258    *\german
 259    *  Diese Funktion wird vom der Laufzeit aufgerufen, falls eine Funktion eine
 260    *  Ausnahme, die nicht in ihrer Ausnahmenspezifikation angegeben ist, wirft.
 261    *  Diese Funktion darf auch direkt aus dem Programm aufgerufen werden.
 262    *
 263    *  unexpected() ruft den momentanen unexpected_handler auf.
 264    *\endgerman
 265    */
 266   void unexpected() _LIGHTLIBCPP_NORETURN;
 267
 268   /*@}*/
 269
 270
 271
 272   /** \addtogroup lightlibcpp_18_8_3 */
 273   /*@{*/
 274
 275   /**
 276    *\english
 277    *  18.8.3.1 Type terminate_handler
 278    *
 279    *  The type of a handler function to be called by terminate() when
 280    *  terminating exception processing.
 281    *
 282    *  A terminate_handler shall terminate execution of the program without
 283    *  returning to the caller.
 284    *
 285    *  The default terminate_handler calls abort().
 286    *\endenglish
 287    *\german
 288    *  18.8.3.1 Typ terminate_handler
 289    *
 290    *  Der Typ einer Handlerfunktion, welche von terminate() aufgerufen wird,
 291    *  wenn die Ausnahmebehandlung terminiert wird (durch den standardmäßig
 292    *  installierten unexpected_handler).
 293    *
 294    *  Ein terminate_handler muss das Programm beenden ohne die Kontrolle zum
 295    *  Aufrufer zurückzugeben
 296    *
 297    *  Der standardmäßig installierte terminate_handler ruft abort() auf.
 298    *\endgerman
 299    */
 300   typedef void (*terminate_handler)() _LIGHTLIBCPP_NORETURN;
 301
 302   /**
 303    *  18.8.3.2 set_terminate
 304    *
 305    *\english
 306    *  The terminate_handler f becomes the new handler called by terminate()
 307    *  \param[in] f a non-null pointer to the new terminate_handler
 308    *  \return a pointer to the previous terminate_handler
 309    *\endenglish
 310    *\german
 311    *  Der terminate_handler f wird der neue Handler, der von terminate()
 312    *  aufgerufen wird
 313    *  \param[in] f ein gültiger Zeiger auf einen terminate_handler
 314    *  \return ein Zeiger auf den vorhergehende terminate_handler
 315    *\endgerman
 316    */
 317   terminate_handler set_terminate(terminate_handler f) throw();
 318
 319   /**
 320    *\english
 321    *  lightlibc++ extension
 322    *
 323    *  Get the current terminate_handler
 324    *  \note This function is needed by the C++ exception handling ABI
 325    *  \return apointer to the current terminate_handler
 326    *\endenglish
 327    *\german
 328    *  lightlibc++ Erweiterung
 329    *
 330    *  Gibt einen Zeiger auf momentan installierten terminate_handler zurück
 331    *  \note Diese Funktion wird von der C++ Ausnahmebehandlungs-ABI benötigt
 332    *  \return ein Zeiger auf den momentan installierten terminate_handler
 333    *\endgerman
 334    */
 335   terminate_handler __get_terminate();
 336
 337   /**
 338    *  18.8.3.3 terminate
 339    *
 340    *\english
 341    *  Called by the default unexpected_handler. May also be called directly by
 342    *  the program.
 343    *
 344    *  Calls the calls the current terminate_handler.
 345    *\endenglish
 346    *\german
 347    *  Diese Funktion wird vom standardmäßig installierten unexpected_handler
 348    *  aufgerufen. Außerdem darf terminate() auch direkt aus dem Programm
 349    *  aufgerufen werden.
 350    *
 351    *  terminate() ruft den momentanen terminate_handler auf.
 352    *\endgerman
 353    */
 354   void terminate() _LIGHTLIBCPP_NORETURN;
 355
 356   /*@}*/
 357
 358
 359
 360   /** \addtogroup lightlibcpp_18_8 */
 361   /*@{*/
 362
 363   // TODO:  bool uncaught_exception() throw(), implemented by the C++ ABI: Exception Handling patch
 364
 365   #ifdef _LIGHTLIBCPP_CPP10
 366     // 18.8.5 Exception Propagation
 367     // TODO C++1x: typedef \unspec exception_ptr;
 368     // TODO C++1x: exception_ptr current_exception();
 369     // TODO C++1x: void rethrow_exception(exception_ptr p);
 370     // TODO C++1x: template<class E> exception_ptr copy_exception(E e);
 371
 372     // TODO 18.8.6 class nested_exception
 373     // TODO template<class T> void throw_with_nested(T&& t); // [[noreturn]]
 374     // TODO template <class E> void rethrow_if_nested(const E& e);
 375   #endif
 376
 377   /*@}*/
 378 }
 379
 380
 381
 382 #endif