home *** CD-ROM | disk | FTP | other *** search
/ PC World 2008 April / PCWorld_2008-04_cd.bin / temacd / devc++ / devcpp-4.9.9.2_setup.exe / cxxabi.h < prev    next >
C/C++ Source or Header  |  2005-01-29  |  16KB  |  529 lines
  1. // new abi support -*- C++ -*-
  2.   
  3. // Copyright (C) 2000, 2002, 2003, 2004 Free Software Foundation, Inc.
  4. //
  5. // This file is part of GCC.
  6. //
  7. // GCC is free software; you can redistribute it and/or modify
  8. // it under the terms of the GNU General Public License as published by
  9. // the Free Software Foundation; either version 2, or (at your option)
  10. // any later version.
  11. // 
  12. // GCC is distributed in the hope that it will be useful,
  13. // but WITHOUT ANY WARRANTY; without even the implied warranty of
  14. // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15. // GNU General Public License for more details.
  16. // 
  17. // You should have received a copy of the GNU General Public License
  18. // along with GCC; see the file COPYING.  If not, write to
  19. // the Free Software Foundation, 59 Temple Place - Suite 330,
  20. // Boston, MA 02111-1307, USA.
  21.  
  22. // As a special exception, you may use this file as part of a free software
  23. // library without restriction.  Specifically, if other files instantiate
  24. // templates or use macros or inline functions from this file, or you compile
  25. // this file and link it with other files to produce an executable, this
  26. // file does not by itself cause the resulting executable to be covered by
  27. // the GNU General Public License.  This exception does not however
  28. // invalidate any other reasons why the executable file might be covered by
  29. // the GNU General Public License.
  30.  
  31. // Written by Nathan Sidwell, Codesourcery LLC, <nathan@codesourcery.com>
  32.  
  33. /* This file declares the new abi entry points into the runtime. It is not
  34.    normally necessary for user programs to include this header, or use the
  35.    entry points directly. However, this header is available should that be
  36.    needed.
  37.    
  38.    Some of the entry points are intended for both C and C++, thus this header
  39.    is includable from both C and C++. Though the C++ specific parts are not
  40.    available in C, naturally enough.  */
  41.  
  42. #ifndef _CXXABI_H
  43. #define _CXXABI_H 1
  44.  
  45. #include <stddef.h>
  46.  
  47. #ifdef __cplusplus
  48. namespace __cxxabiv1
  49. {  
  50.   extern "C" 
  51.   {
  52. #endif
  53.  
  54.   // Allocate array.
  55.   void* 
  56.   __cxa_vec_new(size_t __element_count, size_t __element_size, 
  57.         size_t __padding_size, void (*__constructor) (void*),
  58.         void (*__destructor) (void*));
  59.  
  60.   void*
  61.   __cxa_vec_new2(size_t __element_count, size_t __element_size,
  62.          size_t __padding_size, void (*__constructor) (void*),
  63.          void (*__destructor) (void*), void *(*__alloc) (size_t), 
  64.          void (*__dealloc) (void*));
  65.  
  66.   void*
  67.   __cxa_vec_new3(size_t __element_count, size_t __element_size,
  68.          size_t __padding_size, void (*__constructor) (void*),
  69.          void (*__destructor) (void*), void *(*__alloc) (size_t), 
  70.          void (*__dealloc) (void*, size_t));
  71.  
  72.   // Construct array.
  73.   void 
  74.   __cxa_vec_ctor(void* __array_address, size_t __element_count,
  75.          size_t __element_size, void (*__constructor) (void*),
  76.          void (*__destructor) (void*));
  77.  
  78.   void 
  79.   __cxa_vec_cctor(void* dest_array, void* src_array, size_t element_count, 
  80.           size_t element_size, void (*constructor) (void*, void*), 
  81.           void (*destructor) (void*));
  82.  
  83.   // Destruct array.
  84.   void 
  85.   __cxa_vec_dtor(void* __array_address, size_t __element_count,
  86.          size_t __element_size, void (*__destructor) (void*));
  87.   
  88.   void 
  89.   __cxa_vec_cleanup(void* __array_address, size_t __element_count,
  90.             size_t __element_size, void (*__destructor) (void*));
  91.   
  92.   // Destruct and release array.
  93.   void 
  94.   __cxa_vec_delete(void* __array_address, size_t __element_size,
  95.            size_t __padding_size, void (*__destructor) (void*));
  96.  
  97.   void 
  98.   __cxa_vec_delete2(void* __array_address, size_t __element_size,
  99.             size_t __padding_size, void (*__destructor) (void*),
  100.             void (*__dealloc) (void*));
  101.                   
  102.   void 
  103.   __cxa_vec_delete3(void* __array_address, size_t __element_size,
  104.             size_t __padding_size, void (*__destructor) (void*),
  105.             void (*__dealloc) (void*, size_t));
  106.  
  107.   // The ABI requires a 64-bit type.
  108.   __extension__ typedef int __guard __attribute__((mode (__DI__)));
  109.  
  110.   int 
  111.   __cxa_guard_acquire(__guard*);
  112.  
  113.   void 
  114.   __cxa_guard_release(__guard*);
  115.  
  116.   void 
  117.   __cxa_guard_abort(__guard*);
  118.  
  119.   // Pure virtual functions.
  120.   void
  121.   __cxa_pure_virtual(void);
  122.  
  123.   // Exception handling.
  124.   void
  125.   __cxa_bad_cast();
  126.  
  127.   void
  128.   __cxa_bad_typeid();
  129.  
  130.   // DSO destruction.
  131.   int
  132.   __cxa_atexit(void (*)(void*), void*, void*);
  133.  
  134.   int
  135.   __cxa_finalize(void*);
  136.  
  137.   // Demangling routines. 
  138.   char*
  139.   __cxa_demangle(const char* __mangled_name, char* __output_buffer,
  140.          size_t* __length, int* __status);
  141. #ifdef __cplusplus
  142.   }
  143. } // namespace __cxxabiv1
  144. #endif
  145.  
  146. #ifdef __cplusplus
  147.  
  148. #include <typeinfo>
  149.  
  150. namespace __cxxabiv1
  151. {
  152.   // Type information for int, float etc.
  153.   class __fundamental_type_info : public std::type_info
  154.   {
  155.   public:
  156.     explicit 
  157.     __fundamental_type_info(const char* __n) : std::type_info(__n) { }
  158.  
  159.     virtual 
  160.     ~__fundamental_type_info();
  161.   };
  162.  
  163.   // Type information for array objects.
  164.   class __array_type_info : public std::type_info
  165.   {
  166.   public:
  167.     explicit 
  168.     __array_type_info(const char* __n) : std::type_info(__n) { }
  169.  
  170.     virtual 
  171.     ~__array_type_info();
  172.   };
  173.  
  174.   // Type information for functions (both member and non-member).
  175.   class __function_type_info : public std::type_info
  176.   {
  177.   public:
  178.     explicit 
  179.     __function_type_info(const char* __n) : std::type_info(__n) { }
  180.  
  181.     virtual 
  182.     ~__function_type_info();
  183.  
  184.   protected:
  185.     // Implementation defined member function.
  186.     virtual bool 
  187.     __is_function_p() const;
  188.   };
  189.  
  190.   // Type information for enumerations.
  191.   class __enum_type_info : public std::type_info
  192.   {
  193.   public:
  194.     explicit 
  195.     __enum_type_info(const char* __n) : std::type_info(__n) { }
  196.  
  197.     virtual 
  198.     ~__enum_type_info();
  199.   };
  200.  
  201.   // Common type information for simple pointers and pointers to member.
  202.   class __pbase_type_info : public std::type_info
  203.   {
  204.   public:
  205.     unsigned int         __flags; // Qualification of the target object.
  206.     const std::type_info*     __pointee; // Type of pointed to object.
  207.  
  208.     explicit 
  209.     __pbase_type_info(const char* __n, int __quals, 
  210.               const std::type_info* __type)
  211.     : std::type_info(__n), __flags(__quals), __pointee(__type)
  212.     { }
  213.     
  214.     virtual 
  215.     ~__pbase_type_info();
  216.  
  217.     // Implementation defined type.
  218.     enum __masks 
  219.       {
  220.     __const_mask = 0x1,
  221.     __volatile_mask = 0x2,
  222.     __restrict_mask = 0x4,
  223.     __incomplete_mask = 0x8,
  224.     __incomplete_class_mask = 0x10
  225.       };
  226.  
  227.   protected:
  228.     __pbase_type_info(const __pbase_type_info&);
  229.  
  230.     __pbase_type_info&
  231.     operator=(const __pbase_type_info&);
  232.  
  233.     // Implementation defined member functions.
  234.     virtual bool 
  235.     __do_catch(const std::type_info* __thr_type, void** __thr_obj, 
  236.            unsigned int __outer) const;
  237.  
  238.     inline virtual bool 
  239.     __pointer_catch(const __pbase_type_info* __thr_type, void** __thr_obj,
  240.             unsigned __outer) const;
  241.   };
  242.  
  243.   // Type information for simple pointers.
  244.   class __pointer_type_info : public __pbase_type_info
  245.   {
  246.   public:
  247.     explicit 
  248.     __pointer_type_info(const char* __n, int __quals, 
  249.             const std::type_info* __type)
  250.     : __pbase_type_info (__n, __quals, __type) { }
  251.  
  252.  
  253.     virtual 
  254.     ~__pointer_type_info();
  255.  
  256.   protected:
  257.     // Implementation defined member functions.
  258.     virtual bool 
  259.     __is_pointer_p() const;
  260.  
  261.     virtual bool 
  262.     __pointer_catch(const __pbase_type_info* __thr_type, void** __thr_obj, 
  263.             unsigned __outer) const;
  264.   };
  265.  
  266.   class __class_type_info;
  267.  
  268.   // Type information for a pointer to member variable.
  269.   class __pointer_to_member_type_info : public __pbase_type_info
  270.   {
  271.   public:
  272.     __class_type_info* __context;   // Class of the member.
  273.  
  274.     explicit 
  275.     __pointer_to_member_type_info(const char* __n, int __quals,
  276.                   const std::type_info* __type, 
  277.                   __class_type_info* __klass)
  278.     : __pbase_type_info(__n, __quals, __type), __context(__klass) { }
  279.  
  280.     virtual 
  281.     ~__pointer_to_member_type_info();
  282.  
  283.   protected:
  284.     __pointer_to_member_type_info(const __pointer_to_member_type_info&);
  285.  
  286.     __pointer_to_member_type_info&
  287.     operator=(const __pointer_to_member_type_info&);
  288.  
  289.     // Implementation defined member function.
  290.     virtual bool 
  291.     __pointer_catch(const __pbase_type_info* __thr_type, void** __thr_obj,
  292.             unsigned __outer) const;
  293.   };
  294.  
  295.   // Helper class for __vmi_class_type.
  296.   class __base_class_type_info
  297.   {
  298.   public:
  299.     const __class_type_info*     __base_type;  // Base class type.
  300.     long             __offset_flags;  // Offset and info.
  301.  
  302.     enum __offset_flags_masks 
  303.       {
  304.     __virtual_mask = 0x1,
  305.     __public_mask = 0x2,
  306.     __hwm_bit = 2,
  307.     __offset_shift = 8          // Bits to shift offset.
  308.       };
  309.   
  310.     // Implementation defined member functions.
  311.     bool 
  312.     __is_virtual_p() const
  313.     { return __offset_flags & __virtual_mask; }
  314.  
  315.     bool 
  316.     __is_public_p() const
  317.     { return __offset_flags & __public_mask; }
  318.  
  319.     ptrdiff_t 
  320.     __offset() const
  321.     { 
  322.       // This shift, being of a signed type, is implementation
  323.       // defined. GCC implements such shifts as arithmetic, which is
  324.       // what we want.
  325.       return static_cast<ptrdiff_t>(__offset_flags) >> __offset_shift;
  326.     }
  327.   };
  328.  
  329.   // Type information for a class.
  330.   class __class_type_info : public std::type_info
  331.   {
  332.   public:
  333.     explicit 
  334.     __class_type_info (const char *__n) : type_info(__n) { }
  335.  
  336.     virtual 
  337.     ~__class_type_info ();
  338.  
  339.     // Implementation defined types.
  340.     // The type sub_kind tells us about how a base object is contained
  341.     // within a derived object. We often do this lazily, hence the
  342.     // UNKNOWN value. At other times we may use NOT_CONTAINED to mean
  343.     // not publicly contained.
  344.     enum __sub_kind
  345.       {
  346.     // We have no idea.
  347.     __unknown = 0, 
  348.  
  349.     // Not contained within us (in some circumstances this might
  350.     // mean not contained publicly)
  351.     __not_contained, 
  352.  
  353.     // Contained ambiguously.
  354.     __contained_ambig, 
  355.     
  356.     // Via a virtual path.
  357.     __contained_virtual_mask = __base_class_type_info::__virtual_mask, 
  358.  
  359.     // Via a public path.
  360.     __contained_public_mask = __base_class_type_info::__public_mask,   
  361.  
  362.     // Contained within us.
  363.     __contained_mask = 1 << __base_class_type_info::__hwm_bit,
  364.     
  365.     __contained_private = __contained_mask,
  366.     __contained_public = __contained_mask | __contained_public_mask
  367.       };
  368.  
  369.     struct __upcast_result;
  370.     struct __dyncast_result;
  371.  
  372.   protected:
  373.     // Implementation defined member functions.
  374.     virtual bool 
  375.     __do_upcast(const __class_type_info* __dst_type, void**__obj_ptr) const;
  376.  
  377.     virtual bool 
  378.     __do_catch(const type_info* __thr_type, void** __thr_obj, 
  379.            unsigned __outer) const;
  380.  
  381.   public:
  382.     // Helper for upcast. See if DST is us, or one of our bases. 
  383.     // Return false if not found, true if found. 
  384.     virtual bool 
  385.     __do_upcast(const __class_type_info* __dst, const void* __obj,
  386.         __upcast_result& __restrict __result) const;
  387.  
  388.     // Indicate whether SRC_PTR of type SRC_TYPE is contained publicly
  389.     // within OBJ_PTR. OBJ_PTR points to a base object of our type,
  390.     // which is the destination type. SRC2DST indicates how SRC
  391.     // objects might be contained within this type.  If SRC_PTR is one
  392.     // of our SRC_TYPE bases, indicate the virtuality. Returns
  393.     // not_contained for non containment or private containment.
  394.     inline __sub_kind 
  395.     __find_public_src(ptrdiff_t __src2dst, const void* __obj_ptr,
  396.               const __class_type_info* __src_type, 
  397.               const void* __src_ptr) const;
  398.  
  399.     // Helper for dynamic cast. ACCESS_PATH gives the access from the
  400.     // most derived object to this base. DST_TYPE indicates the
  401.     // desired type we want. OBJ_PTR points to a base of our type
  402.     // within the complete object. SRC_TYPE indicates the static type
  403.     // started from and SRC_PTR points to that base within the most
  404.     // derived object. Fill in RESULT with what we find. Return true
  405.     // if we have located an ambiguous match.
  406.     virtual bool 
  407.     __do_dyncast(ptrdiff_t __src2dst, __sub_kind __access_path,
  408.          const __class_type_info* __dst_type, const void* __obj_ptr, 
  409.          const __class_type_info* __src_type, const void* __src_ptr, 
  410.          __dyncast_result& __result) const;
  411.     
  412.     // Helper for find_public_subobj. SRC2DST indicates how SRC_TYPE
  413.     // bases are inherited by the type started from -- which is not
  414.     // necessarily the current type. The current type will be a base
  415.     // of the destination type.  OBJ_PTR points to the current base.
  416.     virtual __sub_kind 
  417.     __do_find_public_src(ptrdiff_t __src2dst, const void* __obj_ptr,
  418.              const __class_type_info* __src_type,
  419.              const void* __src_ptr) const;
  420.   };
  421.  
  422.   // Type information for a class with a single non-virtual base.
  423.   class __si_class_type_info : public __class_type_info
  424.   {
  425.   public:
  426.     const __class_type_info* __base_type;
  427.  
  428.     explicit 
  429.     __si_class_type_info(const char *__n, const __class_type_info *__base)
  430.     : __class_type_info(__n), __base_type(__base) { }
  431.  
  432.     virtual 
  433.     ~__si_class_type_info();
  434.  
  435.   protected:
  436.     __si_class_type_info(const __si_class_type_info&);
  437.  
  438.     __si_class_type_info&
  439.     operator=(const __si_class_type_info&);
  440.  
  441.     // Implementation defined member functions.
  442.     virtual bool 
  443.     __do_dyncast(ptrdiff_t __src2dst, __sub_kind __access_path,
  444.          const __class_type_info* __dst_type, const void* __obj_ptr,
  445.          const __class_type_info* __src_type, const void* __src_ptr,
  446.          __dyncast_result& __result) const;
  447.  
  448.     virtual __sub_kind 
  449.     __do_find_public_src(ptrdiff_t __src2dst, const void* __obj_ptr,
  450.              const __class_type_info* __src_type,
  451.              const void* __sub_ptr) const;
  452.  
  453.     virtual bool 
  454.     __do_upcast(const __class_type_info*__dst, const void*__obj,
  455.         __upcast_result& __restrict __result) const;
  456.   };
  457.  
  458.   // Type information for a class with multiple and/or virtual bases.
  459.   class __vmi_class_type_info : public __class_type_info 
  460.   {
  461.   public:
  462.     unsigned int         __flags;  // Details about the class hierarchy.
  463.     unsigned int         __base_count;  // Dumber of direct bases.
  464.  
  465.     // The array of bases uses the trailing array struct hack so this
  466.     // class is not constructable with a normal constructor. It is
  467.     // internally generated by the compiler.
  468.     __base_class_type_info     __base_info[1];  // Array of bases.
  469.  
  470.     explicit 
  471.     __vmi_class_type_info(const char* __n, int ___flags)
  472.     : __class_type_info(__n), __flags(___flags), __base_count(0) { }
  473.  
  474.     virtual 
  475.     ~__vmi_class_type_info();
  476.  
  477.     // Implementation defined types.
  478.     enum __flags_masks 
  479.       {
  480.     __non_diamond_repeat_mask = 0x1, // Distinct instance of repeated base.
  481.     __diamond_shaped_mask = 0x2, // Diamond shaped multiple inheritance.
  482.     __flags_unknown_mask = 0x10
  483.       };
  484.  
  485.   protected:
  486.     // Implementation defined member functions.
  487.     virtual bool 
  488.     __do_dyncast(ptrdiff_t __src2dst, __sub_kind __access_path,
  489.          const __class_type_info* __dst_type, const void* __obj_ptr,
  490.          const __class_type_info* __src_type, const void* __src_ptr,
  491.          __dyncast_result& __result) const;
  492.  
  493.     virtual __sub_kind 
  494.     __do_find_public_src(ptrdiff_t __src2dst, const void* __obj_ptr, 
  495.              const __class_type_info* __src_type,
  496.              const void* __src_ptr) const;
  497.     
  498.     virtual bool 
  499.     __do_upcast(const __class_type_info* __dst, const void* __obj,
  500.         __upcast_result& __restrict __result) const;
  501.   };
  502.  
  503.   // Dynamic cast runtime.
  504.   // src2dst has the following possible values
  505.   //  >-1: src_type is a unique public non-virtual base of dst_type
  506.   //       dst_ptr + src2dst == src_ptr
  507.   //   -1: unspecified relationship
  508.   //   -2: src_type is not a public base of dst_type
  509.   //   -3: src_type is a multiple public non-virtual base of dst_type
  510.   extern "C" void*
  511.   __dynamic_cast(const void* __src_ptr, // Starting object.
  512.          const __class_type_info* __src_type, // Static type of object.
  513.          const __class_type_info* __dst_type, // Desired target type.
  514.          ptrdiff_t __src2dst); // How src and dst are related.
  515.  
  516.  
  517.   // Returns the type_info for the currently handled exception [15.3/8], or
  518.   // null if there is none.
  519.   extern "C" std::type_info*
  520.   __cxa_current_exception_type();
  521. } // namespace __cxxabiv1
  522.  
  523. // User programs should use the alias `abi'. 
  524. namespace abi = __cxxabiv1;
  525.  
  526. #endif // __cplusplus
  527.  
  528. #endif // __CXXABI_H 
  529.