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