include/cxxabi.h

   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_CXXABI_H
  18 #define _LIGHTLIBCPP_CXXABI_H
  19
  20
  21
  22 #include <typeinfo>          // std::type_info
  23
  24
  25
  26 /**
  27  *\english
  28  *  \brief internal namespace of the C++ ABI
  29  *\endenglish
  30  *\german
  31  *  \brief intern verwendeter Namensraum der C++ ABI
  32  *\endgerman
  33  */
  34 namespace __cxxabiv1
  35 {
  36 #ifndef _LIGHTLIBCPP_NO_RTTI
  37
  38   /** \addtogroup lightlibcpp_cxxabi_rtti */
  39   /*@{*/
  40
  41   /**
  42    *\english
  43    *  \brief Base class for the runtime type information of the builtin types
  44    *\endenglish
  45    *\german
  46    *  \brief Basisklasse für die Laufzeittypinformation der eingebauten Typen
  47    *\endgerman
  48    */
  49   class __fundamental_type_info : public std::type_info
  50   {
  51     public:
  52       /**
  53        *\english
  54        *  Destructor
  55        *  \note Needed to generate vtables and type information for this class
  56        *        and type information for the builtin types
  57        *\endenglish
  58        *\german
  59        *  Destruktor
  60        *  \note Wird benötigt um vtables und Typinformationen für diese Klasse
  61        *        und Typinformationen für die eingebauten Typen zu generieren
  62        *\endgerman
  63        */
  64       virtual ~__fundamental_type_info();
  65   };
  66
  67   /**
  68    *\english
  69    *  \brief Base class for the runtime type information of array types
  70    *\endenglish
  71    *\german
  72    *  \brief Basisklasse für die Laufzeittypinformationen von Arraytypen
  73    *\endgerman
  74    */
  75   class __array_type_info : public std::type_info
  76   {
  77     public:
  78       /**
  79        *\english
  80        *  Destructor
  81        *  \note Needed to generate vtables and type information for this class
  82        *\endenglish
  83        *\german
  84        *  Destruktor
  85        *  \note Wird benötigt um vtables und Typinformationen für diese Klasse
  86        *        zu generieren
  87        *\endgerman
  88        */
  89       virtual ~__array_type_info();
  90   };
  91
  92   /**
  93    *\english
  94    *  \brief Base class for the runtime type information of (non-member)
  95    *         functions
  96    *\endenglish
  97    *\german
  98    *  \brief Basisklasse für die Laufzeittypinformationen von (nicht-member)
  99    *         Funktionen
 100    *\endgerman
 101    */
 102   class __function_type_info : public std::type_info
 103   {
 104     public:
 105       /**
 106        *\english
 107        *  Destructor
 108        *  \note Needed to generate vtables and type information for this class
 109        *\endenglish
 110        *\german
 111        *  Destruktor
 112        *  \note Wird benötigt um vtables und Typinformationen für diese Klasse
 113        *        zu generieren
 114        *\endgerman
 115        */
 116       virtual ~__function_type_info();
 117   };
 118
 119   /**
 120    *\english
 121    *  \brief Base class for the runtime type information of enumeration types
 122    *\endenglish
 123    *\german
 124    *  \brief Basisklasse für die Laufzeittypinformationen von Enumerationstypen
 125    *\endgerman
 126    */
 127   class __enum_type_info : public std::type_info
 128   {
 129     public:
 130       /**
 131        *\english
 132        *  Destructor
 133        *  \note Needed to generate vtables and type information for this class
 134        *\endenglish
 135        *\german
 136        *  Destruktor
 137        *  \note Wird benötigt um vtables und Typinformationen für diese Klasse
 138        *        zu generieren
 139        *\endgerman
 140        */
 141       virtual ~__enum_type_info();
 142   };
 143
 144   /**
 145    *\english
 146    *  \brief Base class for the runtime type information of class types
 147    *\endenglish
 148    *\german
 149    *  \brief Basiskalsse für die Laufzeittypinformationen von Klassentypen
 150    *\endgerman
 151    */
 152   class __class_type_info : public std::type_info
 153   {
 154     public:
 155       /**
 156        *\english
 157        *  Destructor
 158        *  \note Needed to generate vtables and type information for this class
 159        *\endenglish
 160        *\german
 161        *  Destruktor
 162        *  \note Wird benötigt um vtables und Typinformationen für diese Klasse
 163        *        zu generieren
 164        *\endgerman
 165        */
 166       virtual ~__class_type_info();
 167   };
 168
 169   /**
 170    *\english
 171    *  \brief Base class for the runtime type information of class types with
 172    *         single inheritance
 173    *\endenglish
 174    *\german
 175    *  \brief Basisklasse für die Laufzeittypinformationen von Klassentypen mit
 176    *         Einfachvererbung
 177    *\endgerman
 178    */
 179   class __si_class_type_info : public __class_type_info
 180   {
 181     public:
 182       /**
 183        *\english
 184        *  pointer to the type information of the base class
 185        *\endenglish
 186        *\german
 187        *  Zeiger auf die Typinformationen der Basisklasse
 188        *\endgerman
 189        */
 190       const __class_type_info* __base_type;
 191
 192       /**
 193        *\english
 194        *  Destructor
 195        *  \note Needed to generate vtables and type information for this class
 196        *\endenglish
 197        *\german
 198        *  Destruktor
 199        *  \note Wird benötigt um vtables und Typinformationen für diese Klasse
 200        *        zu generieren
 201        *\endgerman
 202        */
 203       virtual ~__si_class_type_info();
 204   };
 205
 206   /**
 207    *\english
 208    *  \brief Information about a base class in a inheritance hierarchy with
 209    *         multiple inheritance
 210    *\endenglish
 211    *\german
 212    *  \brief Informationen über eine Basisklasse in einer Vererbungshierarchie
 213    *         mit Mehrfachvererbung
 214    *\endgerman
 215    */
 216   struct __base_class_type_info
 217   {
 218     public:
 219       /**
 220        *\english
 221        *  pointer to the type information of the base class
 222        *\endenglish
 223        *\german
 224        *  Zeiger auf die Typinformationen der Basisklasse
 225        *\endgerman
 226        */
 227       const __class_type_info* __base_type;
 228
 229       /**
 230        *\english
 231        *  flags describing the precise type of the inheritance, see
 232        *  __base_class_type_info::__offset_flags_masks
 233        *\endenglish
 234        *\german
 235        *  Flags die den genauen Vererbungstyp angeben, siehe
 236        *  __base_class_type_info::__offset_flags_masks
 237        *\endgerman
 238        */
 239       long                     __offset_flags;
 240
 241       /** \todo document */
 242       enum __offset_flags_masks
 243       {
 244         /** \todo document */
 245         __virtual_mask = 0x01,
 246         /** \todo document */
 247         __public_mask  = 0x02,
 248         /** \todo document */
 249         __offset_shift = 8
 250       };
 251   };
 252
 253   /** \todo document */
 254   class __vmi_class_type_info : public __class_type_info
 255   {
 256     public:
 257       /** \todo document */
 258       unsigned int __flags;
 259       /** \todo document */
 260       unsigned int __base_count;
 261       /** \todo document */
 262       __base_class_type_info __base_info[1];
 263
 264       /** \todo document */
 265       enum __flags_masks
 266       {
 267         /** \todo document */
 268         __non_diamond_repeat_mask = 0x01,
 269         /** \todo document */
 270         __diamond_shaped_mask     = 0x02
 271       };
 272
 273       /**
 274        *\english
 275        *  Destructor
 276        *  \note Needed to generate vtables and type information for this class
 277        *\endenglish
 278        *\german
 279        *  Destruktor
 280        *  \note Wird benötigt um vtables und Typinformationen für diese Klasse
 281        *        zu generieren
 282        *\endgerman
 283        */
 284       virtual ~__vmi_class_type_info();
 285   };
 286
 287   /**
 288    *\english
 289    *  \brief Base class for the runtime type information of pointer types
 290    *         except pointer to non-member functions
 291    *\endenglish
 292    *\german
 293    *  \brief Basisklasse für die Laufzeittypinformationen von Zeigertypen
 294    *         außer Zeiger auf nicht-Memberfunktionen
 295    *\endgerman
 296    */
 297   class __pbase_type_info : public std::type_info
 298   {
 299     public:
 300       /**
 301        *\english
 302        *  flags describing the precise type of the pointer, see __pbase_type_info::__masks
 303        *\endenglish
 304        *\german
 305        *  Flags die den genauen Typ des Zeigers angeben, siehe __pbase_type_info::__masks
 306        *\endgerman
 307        */
 308       unsigned int          __flags;
 309
 310       /**
 311        *\english
 312        *  pointer to the type information of the type pointed to
 313        *\endenglish
 314        *\german
 315        *  Zeiger auf die Typinformationen des Typs auf den der Zeiger zeigt
 316        *\endgerman
 317        */
 318       const std::type_info* __pointee;
 319
 320       /**
 321        *\english
 322        *  flags of the __flags variable
 323        *\endenglish
 324        *\german
 325        *  Flags für die __flags Variable
 326        *\endgerman
 327        */
 328       enum __masks
 329       {
 330         /** const */
 331         __const_mask            = 0x01,
 332
 333         /** volatile */
 334         __volatile_mask         = 0x02,
 335
 336         /** restrict */
 337         __restrict_mask         = 0x04,
 338
 339         /**
 340          *\english
 341          *  incomplete type information
 342          *\endenglish
 343          *\german
 344          *  unvollständige Typinformationen
 345          *\endgerman
 346          */
 347         __incomplete_mask       = 0x08,
 348
 349         /**
 350          *\english
 351          *  incomplete type information for a class type
 352          *\endenglish
 353          *\german
 354          *  unvollständige Typinformationen für einen Klassentyp
 355          *\endgerman
 356          */
 357         __incomplete_class_mask = 0x10
 358       };
 359
 360       /**
 361        *\english
 362        *  Destructor
 363        *  \note Needed to generate vtables and type information for this class
 364        *\endenglish
 365        *\german
 366        *  Destruktor
 367        *  \note Wird benötigt um vtables und Typinformationen für diese Klasse
 368        *        zu generieren
 369        *\endgerman
 370        */
 371       virtual ~__pbase_type_info();
 372   };
 373
 374   /**
 375    *\english
 376    *  \brief Base class for the runtime type information of pointer types
 377    *         except pointer to member
 378    *\endenglish
 379    *\german
 380    *  \brief Basisklasse für die Laufzeittypinformationen von Zeigertypen
 381    *         außer Zeiger auf Klassenmember
 382    *\endgerman
 383    */
 384   class __pointer_type_info : public __pbase_type_info
 385   {
 386     public:
 387       /**
 388        *\english
 389        *  Destructor
 390        *  \note Needed to generate vtables and type information for this class
 391        *\endenglish
 392        *\german
 393        *  Destruktor
 394        *  \note Wird benötigt um vtables und Typinformationen für diese Klasse
 395        *        zu generieren
 396        *\endgerman
 397        */
 398       virtual ~__pointer_type_info();
 399   };
 400
 401   /**
 402    *\english
 403    *  \brief Base class for the runtime type information of pointer-to-member
 404    *         types
 405    *\endenglish
 406    *\german
 407    *  \brief Basisklasse für die Laufzeittypinformationen von Zeiger-auf-Member
 408    *         Typen
 409    *\endgerman
 410    */
 411   class __pointer_to_member_type_info : public __pbase_type_info
 412   {
 413     public:
 414       /**
 415        *\english
 416        *  pointer to the type information of the class of the pointer-to-member
 417        *\endenglish
 418        *\german
 419        *  Zeiger auf die Typinformationen der Klasse des Zeigers-auf-Member
 420        *\endgerman
 421        */
 422       const __class_type_info* __context;
 423
 424       /**
 425        *\english
 426        *  Destructor
 427        *  \note Needed to generate vtables and type information for this class
 428        *\endenglish
 429        *\german
 430        *  Destruktor
 431        *  \note Wird benötigt um vtables und Typinformationen für diese Klasse
 432        *        zu generieren
 433        *\endgerman
 434        */
 435       virtual ~__pointer_to_member_type_info();
 436   };
 437
 438   /*@}*/
 439
 440 #endif
 441 }
 442
 443
 444
 445 /**
 446  *\english
 447  *  \brief Namespace of the C++ ABI
 448  *
 449  *  This namespace contains additionally to those members listed here all
 450  *  members of the __cxxabiv1 namespace.
 451  *\endenglish
 452  *\german
 453  *  \brief Namensraum der C++ ABI
 454  *
 455  *  Dieser Namensraum zusätzlich zu den hier gelisteten alle Elemente aus dem
 456  *  Namensraum __cxxabiv1 .
 457  *\endgerman
 458  */
 459 namespace abi
 460 {
 461   // Lift all classes from __cxxabiv1 to the abi namespace
 462   using namespace __cxxabiv1;
 463
 464
 465
 466   /** \addtogroup lightlibcpp_cxxabi_pure_virtual */
 467   /*@{*/
 468
 469   extern "C"
 470   {
 471     /**
 472      *\english
 473      *  This function is called at runtime if a pure virtual function is being
 474      *  called not overwritten by any derived class.
 475      *
 476      *  __cxa_pure_virtual() does not return to the caller.
 477      *\endenglish
 478      *\german
 479      *  Diese Funktion wird zur Laufzeit aufgerufen, falls eine rein-virtuelle
 480      *  Funktion zum Zeitpunkt des Aufrufs von keiner abgeleiteten Klasse
 481      *  überschrieben wird.
 482      *
 483      *  __cxa_pure_virtual() kehrt nicht zum Aufrufenden zurück.
 484      *\endgerman
 485      */
 486     void __cxa_pure_virtual() _LIGHTLIBCPP_NORETURN;
 487   }
 488
 489   /*@}*/
 490 }
 491
 492
 493
 494 #endif