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