cxxabi.h: Remove duplicated and useless public and private keywords in class declarat...
authorBenjamin Kosnik <bkoz@redhat.com>
Sat, 22 May 2004 21:07:28 +0000 (21:07 +0000)
committerBenjamin Kosnik <bkoz@gcc.gnu.org>
Sat, 22 May 2004 21:07:28 +0000 (21:07 +0000)
2004-05-22  Benjamin Kosnik  <bkoz@redhat.com>

* libsupc++/cxxabi.h: Remove duplicated and useless public and
        private keywords in class declarations. Format. Use
        stddef.h. Expose declarations to "C" compilation.
        * libsupc++/tinfo.cc (__upcast_result): Add copy constructor and
        assignment operator.
        (__dyncast_result): Same.
        * libsupc++/vec.cc (uncatch_exception): Same, use member
        initialization list.

From-SVN: r82147

libstdc++-v3/ChangeLog
libstdc++-v3/libsupc++/cxxabi.h
libstdc++-v3/libsupc++/tinfo.cc
libstdc++-v3/libsupc++/vec.cc

index c2504f9ad36cf4949f4a0145d7e10065f7a79693..5a360726d96afeaa251e435db88d3f9c34044663 100644 (file)
@@ -1,3 +1,14 @@
+2004-05-22  Benjamin Kosnik  <bkoz@redhat.com>
+
+       * libsupc++/cxxabi.h: Remove duplicated and useless public and
+        private keywords in class declarations. Format. Use
+        stddef.h. Expose declarations to "C" compilation.
+        * libsupc++/tinfo.cc (__upcast_result): Add copy constructor and
+        assignment operator.
+        (__dyncast_result): Same.
+        * libsupc++/vec.cc (uncatch_exception): Same, use member
+        initialization list.
+                 
 2004-05-22  Benjamin Kosnik  <bkoz@redhat.com>
 
        * testsuite/abi_check.cc: Add unistd.h.
index f31ce2db1c7b4576fdee868578b63bfcc2ac3711..35535491035b733623a370decd4b5d550f52ce7e 100644 (file)
@@ -1,6 +1,6 @@
 // new abi support -*- C++ -*-
   
-// Copyright (C) 2000, 2002, 2003 Free Software Foundation, Inc.
+// Copyright (C) 2000, 2002, 2003, 2004 Free Software Foundation, Inc.
 //
 // This file is part of GCC.
 //
 #ifndef _CXXABI_H
 #define _CXXABI_H 1
 
+#include <stddef.h>
 #ifdef __cplusplus
+namespace __cxxabiv1
+{  
+  extern "C" 
+  {
+#endif
+
+  // Allocate array.
+  void* 
+  __cxa_vec_new(size_t __element_count, size_t __element_size, 
+               size_t __padding_size, void (*__constructor) (void*),
+               void (*__destructor) (void*));
+
+  void*
+  __cxa_vec_new2(size_t __element_count, size_t __element_size,
+                size_t __padding_size, void (*__constructor) (void*),
+                void (*__destructor) (void*), void *(*__alloc) (size_t), 
+                void (*__dealloc) (void*));
+
+  void*
+  __cxa_vec_new3(size_t __element_count, size_t __element_size,
+                size_t __padding_size, void (*__constructor) (void*),
+                void (*__destructor) (void*), void *(*__alloc) (size_t), 
+                void (*__dealloc) (void*, size_t));
+
+  // Construct array.
+  void 
+  __cxa_vec_ctor(void* __array_address, size_t __element_count,
+                size_t __element_size, void (*__constructor) (void*),
+                void (*__destructor) (void*));
+
+  void 
+  __cxa_vec_cctor(void* dest_array, void* src_array, size_t element_count, 
+                 size_t element_size, void (*constructor) (void*, void*), 
+                 void (*destructor) (void*));
+  // Destruct array.
+  void 
+  __cxa_vec_dtor(void* __array_address, size_t __element_count,
+                size_t __element_size, void (*__destructor) (void*));
+  
+  void 
+  __cxa_vec_cleanup(void* __array_address, size_t __element_count,
+                   size_t __element_size, void (*__destructor) (void*));
+  
+  // Destruct and release array.
+  void 
+  __cxa_vec_delete(void* __array_address, size_t __element_size,
+                  size_t __padding_size, void (*__destructor) (void*));
+
+  void 
+  __cxa_vec_delete2(void* __array_address, size_t __element_size,
+                   size_t __padding_size, void (*__destructor) (void*),
+                   void (*__dealloc) (void*));
+                  
+  void 
+  __cxa_vec_delete3(void* __array_address, size_t __element_size,
+                   size_t __padding_size, void (*__destructor) (void*),
+                   void (*__dealloc) (void*, size_t));
 
-// We use the compiler builtins __SIZE_TYPE__ and __PTRDIFF_TYPE__ instead of
-// std::size_t and std::ptrdiff_t respectively. This makes us independent of
-// the conformance level of <cstddef> and whether -fhonor-std was supplied.
-// <cstddef> is not currently available during compiler building anyway.
-// Including <stddef.h> would be wrong, as that would rudely place size_t in
-// the global namespace.
+  // The ABI requires a 64-bit type.
+  __extension__ typedef int __guard __attribute__((mode (__DI__)));
 
-#include <typeinfo>
+  int 
+  __cxa_guard_acquire(__guard*);
 
-namespace __cxxabiv1
-{
+  void 
+  __cxa_guard_release(__guard*);
 
-/* type information for int, float etc */
-class __fundamental_type_info
-  : public std::type_info
-{
-public:
-  virtual ~__fundamental_type_info ();
-public:
-  explicit __fundamental_type_info (const char *__n)
-    : std::type_info (__n)
-    { }
-};
+  void 
+  __cxa_guard_abort(__guard*);
 
-/* type information for array objects */
-class __array_type_info
-  : public std::type_info
-{
-/* abi defined member functions */
-protected:
-  virtual ~__array_type_info ();
-public:
-  explicit __array_type_info (const char *__n)
-    : std::type_info (__n)
-    { }
-};
+  // Pure virtual functions.
+  void
+  __cxa_pure_virtual(void);
 
-/* type information for functions (both member and non-member) */
-class __function_type_info
-  : public std::type_info
-{
-/* abi defined member functions */
-public:
-  virtual ~__function_type_info ();
-public:
-  explicit __function_type_info (const char *__n)
-    : std::type_info (__n)
-    { }
-  
-/* implementation defined member functions */
-protected:
-  virtual bool __is_function_p () const;
-};
-
-/* type information for enumerations */
-class __enum_type_info
-  : public std::type_info
-{
-/* abi defined member functions */
-public:
-  virtual ~__enum_type_info ();
-public:
-  explicit __enum_type_info (const char *__n)
-    : std::type_info (__n)
-    { }
-};
+  // Exception handling.
+  void
+  __cxa_bad_cast();
 
-/* common type information for simple pointers and pointers to member */
-class __pbase_type_info
-  : public std::type_info
-{
-/* abi defined member variables */
-public:
-  unsigned int __flags; /* qualification of the target object */
-  const std::type_info *__pointee;   /* type of pointed to object */
-
-/* abi defined member functions */
-public:
-  virtual ~__pbase_type_info ();
-public:
-  explicit __pbase_type_info (const char *__n,
-                                int __quals,
-                                const std::type_info *__type)
-    : std::type_info (__n), __flags (__quals), __pointee (__type)
-    { }
+  void
+  __cxa_bad_typeid();
 
-/* implementation defined types */
-public:
-  enum __masks {
-    __const_mask = 0x1,
-    __volatile_mask = 0x2,
-    __restrict_mask = 0x4,
-    __incomplete_mask = 0x8,
-    __incomplete_class_mask = 0x10
-  };
+  // DSO destruction.
+  int
+  __cxa_atexit(void (*)(void*), void*, void*);
 
-/* implementation defined member functions */
-protected:
-  virtual bool __do_catch (const std::type_info *__thr_type,
-                           void **__thr_obj,
-                           unsigned __outer) const;
-protected:
-  inline virtual bool __pointer_catch (const __pbase_type_info *__thr_type,
-                                       void **__thr_obj,
-                                       unsigned __outer) const;
-};
-
-/* type information for simple pointers */
-class __pointer_type_info
-  : public __pbase_type_info
-{
-/* abi defined member functions */
-public:
-  virtual ~__pointer_type_info ();
-public:
-  explicit __pointer_type_info (const char *__n,
-                                int __quals,
-                                const std::type_info *__type)
-    : __pbase_type_info (__n, __quals, __type)
-    { }
+  int
+  __cxa_finalize(void*);
 
-/* implementation defined member functions */
-protected:
-  virtual bool __is_pointer_p () const;
+  // Demangling routines. 
+  char*
+  __cxa_demangle(const char* __mangled_name, char* __output_buffer,
+                size_t* __length, int* __status);
+#ifdef __cplusplus
+  }
+} // namespace __cxxabiv1
+#endif
 
-protected:
-  virtual bool __pointer_catch (const __pbase_type_info *__thr_type,
-                                void **__thr_obj,
-                                unsigned __outer) const;
-};
+#ifdef __cplusplus
 
-class __class_type_info;
+#include <typeinfo>
 
-/* type information for a pointer to member variable */
-class __pointer_to_member_type_info
-  : public __pbase_type_info
+namespace __cxxabiv1
 {
-/* abi defined member variables */
-public:
-  __class_type_info *__context;   /* class of the member */
-
-/* abi defined member functions */
-public:
-  virtual ~__pointer_to_member_type_info ();
-public:
-  explicit __pointer_to_member_type_info (const char *__n,
-                                          int __quals,
-                                          const std::type_info *__type,
-                                          __class_type_info *__klass)
-    : __pbase_type_info (__n, __quals, __type), __context (__klass)
-    { }
+  // Type information for int, float etc.
+  class __fundamental_type_info : public std::type_info
+  {
+  public:
+    explicit 
+    __fundamental_type_info(const char* __n) : std::type_info(__n) { }
 
-/* implementation defined member functions */
-protected:
-  virtual bool __pointer_catch (const __pbase_type_info *__thr_type,
-                                void **__thr_obj,
-                                unsigned __outer) const;
-};
+    virtual 
+    ~__fundamental_type_info();
+  };
 
-/* helper class for __vmi_class_type */
-class __base_class_type_info
-{
-/* abi defined member variables */
-public:
-  const __class_type_info* __base_type;    /* base class type */
-  long __offset_flags;            /* offset and info */
-
-/* implementation defined types */
-public:
-  enum __offset_flags_masks {
-    __virtual_mask = 0x1,
-    __public_mask = 0x2,
-    __hwm_bit = 2,
-    __offset_shift = 8          /* bits to shift offset by */
+  // Type information for array objects.
+  class __array_type_info : public std::type_info
+  {
+  public:
+    explicit 
+    __array_type_info(const char* __n) : std::type_info(__n) { }
+
+    virtual 
+    ~__array_type_info();
   };
-  
-/* implementation defined member functions */
-public:
-  bool __is_virtual_p () const
-    { return __offset_flags & __virtual_mask; }
-  bool __is_public_p () const
-    { return __offset_flags & __public_mask; }
-  __PTRDIFF_TYPE__ __offset () const
-    { 
-      // This shift, being of a signed type, is implementation defined. GCC
-      // implements such shifts as arithmetic, which is what we want.
-      return static_cast<__PTRDIFF_TYPE__> (__offset_flags) >> __offset_shift;
-    }
-};
 
-/* type information for a class */
-class __class_type_info
-  : public std::type_info
-{
-/* abi defined member functions */
-public:
-  virtual ~__class_type_info ();
-public:
-  explicit __class_type_info (const char *__n)
-    : type_info (__n)
-    { }
+  // Type information for functions (both member and non-member).
+  class __function_type_info : public std::type_info
+  {
+  public:
+    explicit 
+    __function_type_info(const char* __n) : std::type_info(__n) { }
 
-/* implementation defined types */
-public:
-  /* sub_kind tells us about how a base object is contained within a derived
-     object. We often do this lazily, hence the UNKNOWN value. At other times
-     we may use NOT_CONTAINED to mean not publicly contained. */
-  enum __sub_kind
+    virtual 
+    ~__function_type_info();
+
+  protected:
+    // Implementation defined member function.
+    virtual bool 
+    __is_function_p() const;
+  };
+
+  // Type information for enumerations.
+  class __enum_type_info : public std::type_info
   {
-    __unknown = 0,              /* we have no idea */
-    __not_contained,            /* not contained within us (in some */
-                                /* circumstances this might mean not contained */
-                                /* publicly) */
-    __contained_ambig,          /* contained ambiguously */
-    
-    __contained_virtual_mask = __base_class_type_info::__virtual_mask, /* via a virtual path */
-    __contained_public_mask = __base_class_type_info::__public_mask,   /* via a public path */
-    __contained_mask = 1 << __base_class_type_info::__hwm_bit,         /* contained within us */
-    
-    __contained_private = __contained_mask,
-    __contained_public = __contained_mask | __contained_public_mask
+  public:
+    explicit 
+    __enum_type_info(const char* __n) : std::type_info(__n) { }
+
+    virtual 
+    ~__enum_type_info();
   };
 
-public:  
-  struct __upcast_result;
-  struct __dyncast_result;
-
-/* implementation defined member functions */
-protected:
-  virtual bool __do_upcast (const __class_type_info *__dst_type, void **__obj_ptr) const;
-
-protected:
-  virtual bool __do_catch (const type_info *__thr_type, void **__thr_obj,
-                           unsigned __outer) const;
-
-
-public:
-  /* Helper for upcast. See if DST is us, or one of our bases. */
-  /* Return false if not found, true if found. */
-  virtual bool __do_upcast (const __class_type_info *__dst,
-                            const void *__obj,
-                            __upcast_result &__restrict __result) const;
-
-public:
-  /* Indicate whether SRC_PTR of type SRC_TYPE is contained publicly within
-     OBJ_PTR. OBJ_PTR points to a base object of our type, which is the
-     destination type. SRC2DST indicates how SRC objects might be contained
-     within this type.  If SRC_PTR is one of our SRC_TYPE bases, indicate the
-     virtuality. Returns not_contained for non containment or private
-     containment. */
-  inline __sub_kind __find_public_src (__PTRDIFF_TYPE__ __src2dst,
-                                       const void *__obj_ptr,
-                                       const __class_type_info *__src_type,
-                                       const void *__src_ptr) const;
-
-public:
-  /* dynamic cast helper. ACCESS_PATH gives the access from the most derived
-     object to this base. DST_TYPE indicates the desired type we want. OBJ_PTR
-     points to a base of our type within the complete object. SRC_TYPE
-     indicates the static type started from and SRC_PTR points to that base
-     within the most derived object. Fill in RESULT with what we find. Return
-     true if we have located an ambiguous match. */
-  virtual bool __do_dyncast (__PTRDIFF_TYPE__ __src2dst,
-                             __sub_kind __access_path,
-                             const __class_type_info *__dst_type,
-                             const void *__obj_ptr,
-                             const __class_type_info *__src_type,
-                             const void *__src_ptr,
-                             __dyncast_result &__result) const;
-public:
-  /* Helper for find_public_subobj. SRC2DST indicates how SRC_TYPE bases are
-     inherited by the type started from -- which is not necessarily the
-     current type. The current type will be a base of the destination type.
-     OBJ_PTR points to the current base. */
-  virtual __sub_kind __do_find_public_src (__PTRDIFF_TYPE__ __src2dst,
-                                           const void *__obj_ptr,
-                                           const __class_type_info *__src_type,
-                                           const void *__src_ptr) const;
-};
-
-/* type information for a class with a single non-virtual base */
-class __si_class_type_info
-  : public __class_type_info
-{
-/* abi defined member variables */
-public:
-  const __class_type_info *__base_type;
-
-/* abi defined member functions */
-public:
-  virtual ~__si_class_type_info ();
-public:
-  explicit __si_class_type_info (const char *__n,
-                                 const __class_type_info *__base)
-    : __class_type_info (__n), __base_type (__base)
+  // Common type information for simple pointers and pointers to member.
+  class __pbase_type_info : public std::type_info
+  {
+  public:
+    unsigned int               __flags; // Qualification of the target object.
+    const std::type_info*      __pointee; // Type of pointed to object.
+
+    explicit 
+    __pbase_type_info(const char* __n, int __quals, 
+                     const std::type_info* __type)
+    : std::type_info(__n), __flags(__quals), __pointee(__type)
     { }
+    
+    virtual 
+    ~__pbase_type_info();
+
+    // Implementation defined type.
+    enum __masks 
+      {
+       __const_mask = 0x1,
+       __volatile_mask = 0x2,
+       __restrict_mask = 0x4,
+       __incomplete_mask = 0x8,
+       __incomplete_class_mask = 0x10
+      };
+
+  protected:
+    __pbase_type_info(const __pbase_type_info&);
+
+    __pbase_type_info&
+    operator=(const __pbase_type_info&);
+
+    // Implementation defined member functions.
+    virtual bool 
+    __do_catch(const std::type_info* __thr_type, void** __thr_obj, 
+              unsigned int __outer) const;
+
+    inline virtual bool 
+    __pointer_catch(const __pbase_type_info* __thr_type, void** __thr_obj,
+                   unsigned __outer) const;
+  };
 
-/* implementation defined member functions */
-protected:
-  virtual bool __do_dyncast (__PTRDIFF_TYPE__ __src2dst,
-                             __sub_kind __access_path,
-                             const __class_type_info *__dst_type,
-                             const void *__obj_ptr,
-                             const __class_type_info *__src_type,
-                             const void *__src_ptr,
-                             __dyncast_result &__result) const;
-  virtual __sub_kind __do_find_public_src (__PTRDIFF_TYPE__ __src2dst,
-                                           const void *__obj_ptr,
-                                           const __class_type_info *__src_type,
-                                           const void *__sub_ptr) const;
-  virtual bool __do_upcast (const __class_type_info *__dst,
-                            const void *__obj,
-                            __upcast_result &__restrict __result) const;
-};
-
-/* type information for a class with multiple and/or virtual bases */
-class __vmi_class_type_info : public __class_type_info {
-/* abi defined member variables */
-public:
-  unsigned int __flags;         /* details about the class hierarchy */
-  unsigned int __base_count;    /* number of direct bases */
-  __base_class_type_info __base_info[1]; /* array of bases */
-  /* The array of bases uses the trailing array struct hack
-     so this class is not constructable with a normal constructor. It is
-     internally generated by the compiler. */
-
-/* abi defined member functions */
-public:
-  virtual ~__vmi_class_type_info ();
-public:
-  explicit __vmi_class_type_info (const char *__n,
-                                  int ___flags)
-    : __class_type_info (__n), __flags (___flags), __base_count (0)
-    { }
+  // Type information for simple pointers.
+  class __pointer_type_info : public __pbase_type_info
+  {
+  public:
+    explicit 
+    __pointer_type_info(const char* __n, int __quals, 
+                       const std::type_info* __type)
+    : __pbase_type_info (__n, __quals, __type) { }
+
+
+    virtual 
+    ~__pointer_type_info();
 
-/* implementation defined types */
-public:
-  enum __flags_masks {
-    __non_diamond_repeat_mask = 0x1,   /* distinct instance of repeated base */
-    __diamond_shaped_mask = 0x2,       /* diamond shaped multiple inheritance */
-    __flags_unknown_mask = 0x10
+  protected:
+    // Implementation defined member functions.
+    virtual bool 
+    __is_pointer_p() const;
+
+    virtual bool 
+    __pointer_catch(const __pbase_type_info* __thr_type, void** __thr_obj, 
+                   unsigned __outer) const;
   };
 
-/* implementation defined member functions */
-protected:
-  virtual bool __do_dyncast (__PTRDIFF_TYPE__ __src2dst,
-                             __sub_kind __access_path,
-                             const __class_type_info *__dst_type,
-                             const void *__obj_ptr,
-                             const __class_type_info *__src_type,
-                             const void *__src_ptr,
-                             __dyncast_result &__result) const;
-  virtual __sub_kind __do_find_public_src (__PTRDIFF_TYPE__ __src2dst,
-                                           const void *__obj_ptr,
-                                           const __class_type_info *__src_type,
-                                           const void *__src_ptr) const;
-  virtual bool __do_upcast (const __class_type_info *__dst,
-                            const void *__obj,
-                            __upcast_result &__restrict __result) const;
-};
-
-/* dynamic cast runtime */
-extern "C"
-void *__dynamic_cast (const void *__src_ptr,    /* object started from */
-                      const __class_type_info *__src_type, /* static type of object */
-                      const __class_type_info *__dst_type, /* desired target type */
-                      __PTRDIFF_TYPE__ __src2dst); /* how src and dst are related */
-
-    /* src2dst has the following possible values
-       >= 0: src_type is a unique public non-virtual base of dst_type
-             dst_ptr + src2dst == src_ptr
-       -1: unspecified relationship
-       -2: src_type is not a public base of dst_type
-       -3: src_type is a multiple public non-virtual base of dst_type */
-
-/* array ctor/dtor routines */
-
-/* allocate and construct array */
-extern "C"
-void *__cxa_vec_new (__SIZE_TYPE__ __element_count,
-                     __SIZE_TYPE__ __element_size,
-                     __SIZE_TYPE__ __padding_size,
-                     void (*__constructor) (void *),
-                     void (*__destructor) (void *));
-
-extern "C"
-void *__cxa_vec_new2 (__SIZE_TYPE__ __element_count,
-                      __SIZE_TYPE__ __element_size,
-                      __SIZE_TYPE__ __padding_size,
-                      void (*__constructor) (void *),
-                      void (*__destructor) (void *),
-                      void *(*__alloc) (__SIZE_TYPE__),
-                      void (*__dealloc) (void *));
-
-extern "C"
-void *__cxa_vec_new3 (__SIZE_TYPE__ __element_count,
-                      __SIZE_TYPE__ __element_size,
-                      __SIZE_TYPE__ __padding_size,
-                      void (*__constructor) (void *),
-                      void (*__destructor) (void *),
-                      void *(*__alloc) (__SIZE_TYPE__),
-                      void (*__dealloc) (void *, __SIZE_TYPE__));
-
-/* construct array */
-extern "C"
-void __cxa_vec_ctor (void *__array_address,
-                     __SIZE_TYPE__ __element_count,
-                     __SIZE_TYPE__ __element_size,
-                     void (*__constructor) (void *),
-                     void (*__destructor) (void *));
-
-extern "C"
-void __cxa_vec_cctor (void *dest_array,
-                     void *src_array,
-                     __SIZE_TYPE__ element_count,
-                     __SIZE_TYPE__ element_size,
-                     void (*constructor) (void *, void *),
-                     void (*destructor) (void *));
-/* destruct array */
-extern "C"
-void __cxa_vec_dtor (void *__array_address,
-                     __SIZE_TYPE__ __element_count,
-                     __SIZE_TYPE__ __element_size,
-                     void (*__destructor) (void *));
-
-/* destruct array */
-extern "C"
-void __cxa_vec_cleanup (void *__array_address,
-                       __SIZE_TYPE__ __element_count,
-                       __SIZE_TYPE__ __element_size,
-                       void (*__destructor) (void *));
-
-/* destruct and release array */
-extern "C"
-void __cxa_vec_delete (void *__array_address,
-                       __SIZE_TYPE__ __element_size,
-                       __SIZE_TYPE__ __padding_size,
-                       void (*__destructor) (void *));
-
-extern "C"
-void __cxa_vec_delete2 (void *__array_address,
-                        __SIZE_TYPE__ __element_size,
-                        __SIZE_TYPE__ __padding_size,
-                        void (*__destructor) (void *),
-                        void (*__dealloc) (void *));
-                  
-extern "C"
-void __cxa_vec_delete3 (void *__array_address,
-                        __SIZE_TYPE__ __element_size,
-                        __SIZE_TYPE__ __padding_size,
-                        void (*__destructor) (void *),
-                        void (*__dealloc) (void *, __SIZE_TYPE__));
+  class __class_type_info;
 
-/* guard variables */
+  // Type information for a pointer to member variable.
+  class __pointer_to_member_type_info : public __pbase_type_info
+  {
+  public:
+    __class_type_info* __context;   // Class of the member.
 
-/* The ABI requires a 64-bit type.  */
-__extension__ typedef int __guard __attribute__((mode (__DI__)));
+    explicit 
+    __pointer_to_member_type_info(const char* __n, int __quals,
+                                 const std::type_info* __type, 
+                                 __class_type_info* __klass)
+    : __pbase_type_info(__n, __quals, __type), __context(__klass) { }
 
-extern "C"
-int __cxa_guard_acquire (__guard *);
+    virtual 
+    ~__pointer_to_member_type_info();
 
-extern "C"
-void __cxa_guard_release (__guard *);
+  protected:
+    __pointer_to_member_type_info(const __pointer_to_member_type_info&);
 
-extern "C"
-void __cxa_guard_abort (__guard *);
+    __pointer_to_member_type_info&
+    operator=(const __pointer_to_member_type_info&);
 
-/* pure virtual functions */
+    // Implementation defined member function.
+    virtual bool 
+    __pointer_catch(const __pbase_type_info* __thr_type, void** __thr_obj,
+                   unsigned __outer) const;
+  };
 
-extern "C" void
-__cxa_pure_virtual (void);
+  // Helper class for __vmi_class_type.
+  class __base_class_type_info
+  {
+  public:
+    const __class_type_info*   __base_type;  // Base class type.
+    long                       __offset_flags;  // Offset and info.
+
+    enum __offset_flags_masks 
+      {
+       __virtual_mask = 0x1,
+       __public_mask = 0x2,
+       __hwm_bit = 2,
+       __offset_shift = 8          // Bits to shift offset.
+      };
+  
+    // Implementation defined member functions.
+    bool 
+    __is_virtual_p() const
+    { return __offset_flags & __virtual_mask; }
+
+    bool 
+    __is_public_p() const
+    { return __offset_flags & __public_mask; }
+
+    ptrdiff_t 
+    __offset() const
+    { 
+      // This shift, being of a signed type, is implementation
+      // defined. GCC implements such shifts as arithmetic, which is
+      // what we want.
+      return static_cast<ptrdiff_t>(__offset_flags) >> __offset_shift;
+    }
+  };
+
+  // Type information for a class.
+  class __class_type_info : public std::type_info
+  {
+  public:
+    explicit 
+    __class_type_info (const char *__n) : type_info(__n) { }
+
+    virtual 
+    ~__class_type_info ();
+
+    // Implementation defined types.
+    // The type sub_kind tells us about how a base object is contained
+    // within a derived object. We often do this lazily, hence the
+    // UNKNOWN value. At other times we may use NOT_CONTAINED to mean
+    // not publicly contained.
+    enum __sub_kind
+      {
+       // We have no idea.
+       __unknown = 0, 
+
+       // Not contained within us (in some circumstances this might
+       // mean not contained publicly)
+       __not_contained, 
+
+       // Contained ambiguously.
+       __contained_ambig, 
+    
+       // Via a virtual path.
+       __contained_virtual_mask = __base_class_type_info::__virtual_mask, 
 
-/* exception handling */
+       // Via a public path.
+       __contained_public_mask = __base_class_type_info::__public_mask,   
 
-extern "C" void
-__cxa_bad_cast ();
+       // Contained within us.
+       __contained_mask = 1 << __base_class_type_info::__hwm_bit,
+    
+       __contained_private = __contained_mask,
+       __contained_public = __contained_mask | __contained_public_mask
+      };
+
+    struct __upcast_result;
+    struct __dyncast_result;
+
+  protected:
+    // Implementation defined member functions.
+    virtual bool 
+    __do_upcast(const __class_type_info* __dst_type, void**__obj_ptr) const;
+
+    virtual bool 
+    __do_catch(const type_info* __thr_type, void** __thr_obj, 
+              unsigned __outer) const;
+
+  public:
+    // Helper for upcast. See if DST is us, or one of our bases. 
+    // Return false if not found, true if found. 
+    virtual bool 
+    __do_upcast(const __class_type_info* __dst, const void* __obj,
+               __upcast_result& __restrict __result) const;
+
+    // Indicate whether SRC_PTR of type SRC_TYPE is contained publicly
+    // within OBJ_PTR. OBJ_PTR points to a base object of our type,
+    // which is the destination type. SRC2DST indicates how SRC
+    // objects might be contained within this type.  If SRC_PTR is one
+    // of our SRC_TYPE bases, indicate the virtuality. Returns
+    // not_contained for non containment or private containment.
+    inline __sub_kind 
+    __find_public_src(ptrdiff_t __src2dst, const void* __obj_ptr,
+                     const __class_type_info* __src_type, 
+                     const void* __src_ptr) const;
+
+    // Helper for dynamic cast. ACCESS_PATH gives the access from the
+    // most derived object to this base. DST_TYPE indicates the
+    // desired type we want. OBJ_PTR points to a base of our type
+    // within the complete object. SRC_TYPE indicates the static type
+    // started from and SRC_PTR points to that base within the most
+    // derived object. Fill in RESULT with what we find. Return true
+    // if we have located an ambiguous match.
+    virtual bool 
+    __do_dyncast(ptrdiff_t __src2dst, __sub_kind __access_path,
+                const __class_type_info* __dst_type, const void* __obj_ptr, 
+                const __class_type_info* __src_type, const void* __src_ptr, 
+                __dyncast_result& __result) const;
+    
+    // Helper for find_public_subobj. SRC2DST indicates how SRC_TYPE
+    // bases are inherited by the type started from -- which is not
+    // necessarily the current type. The current type will be a base
+    // of the destination type.  OBJ_PTR points to the current base.
+    virtual __sub_kind 
+    __do_find_public_src(ptrdiff_t __src2dst, const void* __obj_ptr,
+                        const __class_type_info* __src_type,
+                        const void* __src_ptr) const;
+  };
+
+  // Type information for a class with a single non-virtual base.
+  class __si_class_type_info : public __class_type_info
+  {
+  public:
+    const __class_type_info* __base_type;
 
-extern "C" void
-__cxa_bad_typeid ();
+    explicit 
+    __si_class_type_info(const char *__n, const __class_type_info *__base)
+    : __class_type_info(__n), __base_type(__base) { }
 
-/* DSO destruction */
+    virtual 
+    ~__si_class_type_info();
 
-extern "C" int
-__cxa_atexit (void (*)(void *), void *, void *);
+  protected:
+    __si_class_type_info(const __si_class_type_info&);
 
-extern "C" int
-__cxa_finalize (void *);
+    __si_class_type_info&
+    operator=(const __si_class_type_info&);
 
-/* demangling routines */
+    // Implementation defined member functions.
+    virtual bool 
+    __do_dyncast(ptrdiff_t __src2dst, __sub_kind __access_path,
+                const __class_type_info* __dst_type, const void* __obj_ptr,
+                const __class_type_info* __src_type, const void* __src_ptr,
+                __dyncast_result& __result) const;
 
-extern "C" 
-char *__cxa_demangle (const char *__mangled_name,
-                     char *__output_buffer,
-                     __SIZE_TYPE__ *__length,
-                     int *__status);
+    virtual __sub_kind 
+    __do_find_public_src(ptrdiff_t __src2dst, const void* __obj_ptr,
+                        const __class_type_info* __src_type,
+                        const void* __sub_ptr) const;
 
-// Returns the type_info for the currently handled exception [15.3/8], or
-// null if there is none.
-extern "C"
-std::type_info *__cxa_current_exception_type ();
+    virtual bool 
+    __do_upcast(const __class_type_info*__dst, const void*__obj,
+               __upcast_result& __restrict __result) const;
+  };
 
-} /* namespace __cxxabiv1 */
+  // Type information for a class with multiple and/or virtual bases.
+  class __vmi_class_type_info : public __class_type_info 
+  {
+  public:
+    unsigned int               __flags;  // Details about the class hierarchy.
+    unsigned int               __base_count;  // Dumber of direct bases.
+
+    // The array of bases uses the trailing array struct hack so this
+    // class is not constructable with a normal constructor. It is
+    // internally generated by the compiler.
+    __base_class_type_info     __base_info[1];  // Array of bases.
+
+    explicit 
+    __vmi_class_type_info(const char* __n, int ___flags)
+    : __class_type_info(__n), __flags(___flags), __base_count(0) { }
+
+    virtual 
+    ~__vmi_class_type_info();
+
+    // Implementation defined types.
+    enum __flags_masks 
+      {
+       __non_diamond_repeat_mask = 0x1, // Distinct instance of repeated base.
+       __diamond_shaped_mask = 0x2, // Diamond shaped multiple inheritance.
+       __flags_unknown_mask = 0x10
+      };
+
+  protected:
+    // Implementation defined member functions.
+    virtual bool 
+    __do_dyncast(ptrdiff_t __src2dst, __sub_kind __access_path,
+                const __class_type_info* __dst_type, const void* __obj_ptr,
+                const __class_type_info* __src_type, const void* __src_ptr,
+                __dyncast_result& __result) const;
+
+    virtual __sub_kind 
+    __do_find_public_src(ptrdiff_t __src2dst, const void* __obj_ptr, 
+                        const __class_type_info* __src_type,
+                        const void* __src_ptr) const;
+    
+    virtual bool 
+    __do_upcast(const __class_type_info* __dst, const void* __obj,
+               __upcast_result& __restrict __result) const;
+  };
 
-/* User programs should use the alias `abi'. */
+  // Dynamic cast runtime.
+  // src2dst has the following possible values
+  //  >-1: src_type is a unique public non-virtual base of dst_type
+  //       dst_ptr + src2dst == src_ptr
+  //   -1: unspecified relationship
+  //   -2: src_type is not a public base of dst_type
+  //   -3: src_type is a multiple public non-virtual base of dst_type
+  extern "C" void*
+  __dynamic_cast(const void* __src_ptr, // Starting object.
+                const __class_type_info* __src_type, // Static type of object.
+                const __class_type_info* __dst_type, // Desired target type.
+                ptrdiff_t __src2dst); // How src and dst are related.
+
+
+  // Returns the type_info for the currently handled exception [15.3/8], or
+  // null if there is none.
+  extern "C" std::type_info*
+  __cxa_current_exception_type();
+} // namespace __cxxabiv1
+
+// User programs should use the alias `abi'. 
 namespace abi = __cxxabiv1;
 
-#else
-#endif /* __cplusplus */
-
+#endif // __cplusplus
 
-#endif /* __CXXABI_H */
+#endif // __CXXABI_H 
index c28217659461c704539f36f37fea380ac3372131..ed6500697f0e6c2a27e0f1128a8643bea8b79b66 100644 (file)
@@ -200,10 +200,28 @@ struct __class_type_info::__upcast_result
                               // if in vbase the __class_type_info of vbase
                               // if a non-virtual base then 1
                               // else NULL
-  public:
   __upcast_result (int d)
     :dst_ptr (NULL), part2dst (__unknown), src_details (d), base_type (NULL)
     {}
+
+  explicit
+  __upcast_result(const __upcast_result& r)
+  : dst_ptr(r.dst_ptr), part2dst(r.part2dst), src_details(r.src_details), 
+    base_type(r.base_type) 
+  { }
+
+  __upcast_result&
+  operator=(const __upcast_result& r)
+  {
+    if (&r != this)
+      {
+       dst_ptr = r.dst_ptr;
+       part2dst = r.part2dst;
+       src_details = r.src_details;
+       base_type = r.base_type;
+      }
+    return *this;
+  }
 };
 
 // __dyncast_result is used to hold information during traversal of a class
@@ -216,12 +234,17 @@ struct __class_type_info::__dyncast_result
   __sub_kind dst2src;         // path from target to sub object
   int whole_details;          // details of the whole class hierarchy
   
-  public:
   __dyncast_result (int details_ = __vmi_class_type_info::__flags_unknown_mask)
     :dst_ptr (NULL), whole2dst (__unknown),
      whole2src (__unknown), dst2src (__unknown),
      whole_details (details_)
     {}
+
+protected:
+  __dyncast_result(const __dyncast_result&);
+  
+  __dyncast_result&
+  operator=(const __dyncast_result&);
 };
 
 bool __class_type_info::
index 908fe9978dee3e3c15f644f6d90751e8c763636f..86d41d9ea98b4a49dc868b6898d1cfc86b7a9043 100644 (file)
@@ -1,6 +1,6 @@
 // New abi Support -*- C++ -*-
 
-// Copyright (C) 2000, 2001, 2003 Free Software Foundation, Inc.
+// Copyright (C) 2000, 2001, 2003, 2004 Free Software Foundation, Inc.
 //  
 // This file is part of GCC.
 //
@@ -42,13 +42,19 @@ namespace __cxxabiv1
   {
     struct uncatch_exception 
     {
-      uncatch_exception ();
+      uncatch_exception();
       ~uncatch_exception () { __cxa_begin_catch (&p->unwindHeader); }
       
-      __cxa_exception *p;
+      __cxa_exception* p;
+
+    private:
+      uncatch_exception&
+      operator=(const uncatch_exception&);
+
+      uncatch_exception(const uncatch_exception&);
     };
 
-    uncatch_exception::uncatch_exception ()
+    uncatch_exception::uncatch_exception() : p(0)
     {
       __cxa_eh_globals *globals = __cxa_get_globals_fast ();