OpenE2K/gcc
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Makefile.am (LIBSUPCXX_INCLUDES): Adjust.

Browse Source 
2000-10-10  Benjamin Kosnik  <bkoz@purist.soma.redhat.com>

	* Makefile.am (LIBSUPCXX_INCLUDES): Adjust.
	* libsupc++/include: Remove
	* libsupc++/include/*: Move to ...
	* libsupc++: Here.
	* libsupc++/Makefile.am (glibcppinstall_HEADERS): Install headers.
	(glibcppinstalldir): New.

	* src/Makefile.am (c_base_headers): New.
	(c_shadow_headers): New
	(c_headers): New.
	(myinstallheaders): Correct install issues.
	* src/Makefile.in: Regenerate.

	* Makefile.am (CSHADOW_INCLUDES): Simplify.
	* Makefile.in: Regenerate.
	* acinclude.m4 (GLIBCPP_ENABLE_SHADOW): Add c_include_dir.
	* aclocal.m4: Regenerate.
	* mkcheck.in (SRC_DIR): Use it.

	* include/bits/std_stdexcept.h: And here.
	* include/bits/std_ios.h: Change std_exception.h to exception.
	* src/locale.cc: And here.
	* src/locale-inst.cc: And here.

	* include/bits/valarray_array.h: And here.
	* include/bits/stl_alloc.h: And here.
	* include/bits/stl_algobase.h: And here.
	* include/bits/pthread_allocimpl.h: And here.
	* include/bits/stl_construct.h: Change to std_new.h to new.

	* include/bits/locale_facets.h: Change std_typeinfo.h to typeinfo.

	* src/Makefile.am (INCLUDES): Add LIBSUPCXX_INCLUDES.
	(headers): Remove duplicated headers.
	(std_headers): And here.
	* src/Makefile.in: Regenerate.
	* libsupc++/Makefile.am (LIBSUPCXX_INCLUDES): Remove.
	* libsupc++/Makefile.in: Regenerate.
	* Makefile.am (LIBSUPCXX_INCLUDES): Add here.
	(AM_MAKEFLAGS): And here.
	* Makefile.in: Regenerate.
	* include/bits/std_typeinfo.h: Remove.
	* include/bits/std_new.h: Remove
	* include/bits/std_exception.h: Remove.
	* std/new: Remove.
	* std/typeinfo: Remove.
	* std/exception: Remove.

	* libio/_G_config.h (__need_ptrdiff_t): Add.

	* libsupc++/include/new: Change stddef.h to cstddef.
	* libsupc++/tinfo.h: Change limits.h to climits.
	* libsupc++/pure.cc: Comment out _GNU_LIBRARY_ bits, as this
	renders the file uncompilable. Add copyright.

	* include/c_std/bits/std_cstddef.h: Don't bring wchar_t into std
	namespace, as it is a fundamental type.

From-SVN: r36832
This commit is contained in:
Benjamin Kosnik 2000-10-10 23:43:26 +00:00
parent 01ce962b94
commit 6305f20ac3
11 changed files with 825 additions and 253 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

81
libstdc++-v3/include/bits/std_exception.h
View File

@ -1,81 +0,0 @@
// Copyright (C) 1997-1999 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 2, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING. If not, write to the Free
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
// USA.
// As a special exception, you may use this file as part of a free software
// library without restriction. Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the GNU General Public License. This exception does not however
// invalidate any other reasons why the executable file might be covered by
// the GNU General Public License.
#ifndef _CPP_EXCEPTION
#define _CPP_EXCEPTION 1
#ifdef __GNUG__
#pragma GCC system_header
#include_next <exception>
#else
#include <bits/stl_config.h>
__STL_BEGIN_NAMESPACE
// 18.6 Exception handling
class exception;
class bad_exception;
typedef void (*unexpected_handler)();
unexpected_handler set_unexpected(unexpected_handler) throw();
void unexpected();
typedef void (*terminate_handler)();
terminate_handler set_terminate(terminate_handler) throw();
void terminate();
bool uncaught_exception();
// 18.6.1 Class exception
class exception {
public:
exception() throw();
exception(const exception&) throw();
exception& operator=(const exception&) throw();
virtual ~exception() throw();
virtual const char* what() const throw();
};
// 18.6.2.1 Class bad_exception
class bad_exception : public exception {
public:
bad_exception() throw();
bad_exception(const bad_exception&) throw();
bad_exception& operator=(const bad_exception&) throw();
virtual ~bad_exception() throw();
virtual const char* what() const throw();
};
__STL_END_NAMESPACE
#endif /* __GNUG__ */
#endif /* _CPP_EXCEPTION */
// Local Variables:
// mode:C++
// End:

82
libstdc++-v3/include/bits/std_new.h
View File

@ -1,82 +0,0 @@
// Copyright (C) 1997-1999 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 2, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING. If not, write to the Free
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
// USA.
// As a special exception, you may use this file as part of a free software
// library without restriction. Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the GNU General Public License. This exception does not however
// invalidate any other reasons why the executable file might be covered by
// the GNU General Public License.
#ifndef _CPP_NEW
#define _CPP_NEW 1
#include <bits/c++config.h>
#ifdef __GNUG__
# pragma GCC system_header
# include_next <new>
#else
#include <bits/std_exception.h>
// 18.4 Dynamic memory management
__STL_BEGIN_NAMESPACE
class bad_alloc;
struct nothrow_t {};
extern const nothrow_t nothrow;
typedef void (*new_handler)();
new_handler set_new_handler(new_handler) throw();
class bad_alloc : public exception {
public:
bad_alloc() throw();
bad_alloc(const bad_alloc&) throw();
bad_alloc& operator=(const bad_alloc&) throw();
virtual ~bad_alloc() throw();
virtual const char* what() const throw();
};
__STL_END_NAMESPACE
void* operator new(__STD::size_t) throw(__STD::bad_alloc);
void* operator new(__STD::size_t, const __STD::nothrow_t&) throw();
void operator delete(void*) throw();
void operator delete(void*, const __STD::nothrow_t&) throw();
void* operator new[](__STD::size_t) throw(__STD::bad_alloc);
void* operator new[](__STD::size_t, const __STD::nothrow_t&) throw();
void operator delete[](void*) throw();
void operator delete[](void*, const __STD::nothrow_t&) throw();
void* operator new (__STD::size_t, void*) throw();
void* operator new[](__STD::size_t, void*) throw();
void operator delete (void*, void*) throw();
void operator delete[](void*, void*) throw();
#endif
#endif /* _CPP_NEW */
// Local Variables:
// mode:C++
// End:

81
libstdc++-v3/include/bits/std_typeinfo.h
View File

@ -1,81 +0,0 @@
// Copyright (C) 1997-1999 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 2, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING. If not, write to the Free
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
// USA.
// As a special exception, you may use this file as part of a free software
// library without restriction. Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the GNU General Public License. This exception does not however
// invalidate any other reasons why the executable file might be covered by
// the GNU General Public License.
#ifndef _CPP_TYPEINFO
#define _CPP_TYPEINFO 1
#include <bits/c++config.h>
#include <bits/std_exception.h>
#ifdef __GNUG__
# pragma GCC system_header
# include_next <typeinfo>
#else
__STL_BEGIN_NAMESPACE
class type_info {
public:
virtual ~type_info();
bool operator==(const type_info& rhs) const;
bool operator!=(const type_info& rhs) const;
bool before(const type_info& rhs) const;
const char* name() const;
private:
type_info(const type_info& rhs);
type_info& operator=(const type_info& rhs);
};
class bad_cast : public exception {
public:
bad_cast() throw();
bad_cast(const bad_cast&) throw();
bad_cast& operator=(const bad_cast&) throw();
virtual ~bad_cast() throw();
virtual const char* what() const throw();
};
class bad_typeid : public exception {
public:
bad_typeid() throw();
bad_typeid(const bad_typeid&) throw();
bad_typeid& operator=(const bad_typeid&) throw();
virtual ~bad_typeid() throw();
virtual const char* what() const throw();
};
__STL_END_NAMESPACE
#endif
#endif /* _CPP_TYPEINFO */
// Local Variables:
// mode:C++
// End:

3
libstdc++-v3/include/std/exception
View File

@ -1,3 +0,0 @@
#ifndef _CPP_EXCEPTION
#include <bits/std_exception.h>
#endif

3
libstdc++-v3/include/std/new
View File

@ -1,3 +0,0 @@
#ifndef _CPP_NEW
#include <bits/std_new.h>
#endif

3
libstdc++-v3/include/std/typeinfo
View File

@ -1,3 +0,0 @@
#ifndef _CPP_TYPEINFO
#include <bits/std_typeinfo.h>
#endif

519
libstdc++-v3/libsupc++/cxxabi.h Normal file
View File

@ -0,0 +1,519 @@
/* new abi support -*- C++ -*-
Copyright (C) 2000
Free Software Foundation, Inc.
Written by Nathan Sidwell, Codesourcery LLC, <nathan@codesourcery.com> */
// This file is part of GNU CC.
//
// GNU CC is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2, or (at your option)
// any later version.
//
// GNU CC is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with GNU CC; see the file COPYING. If not, write to
// the Free Software Foundation, 59 Temple Place - Suite 330,
// Boston, MA 02111-1307, USA.
// As a special exception, you may use this file as part of a free software
// library without restriction. Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the GNU General Public License. This exception does not however
// invalidate any other reasons why the executable file might be covered by
// the GNU General Public License.
/* This file declares the new abi entry points into the runtime. It is not
normally necessary for user programs to include this header, or use the
entry points directly. However, this header is available should that be
needed.
Some of the entry points are intended for both C and C++, thus this header
is includable from both C and C++. Though the C++ specific parts are not
available in C, naturally enough. */
#ifndef __CXXABI_H
#define __CXXABI_H 1
#if defined(__cplusplus) && (!defined(__GXX_ABI_VERSION) || __GXX_ABI_VERSION < 100)
/* These structures only make sense when targeting the new abi, catch a
bonehead error early rather than let the user get very confused. */
#error "Not targetting the new abi, supply -fnew-abi"
#endif
#ifdef __cplusplus
// We use the compiler builtins __SIZE_TYPE__ and __PTRDIFF_TYPE__ instead of
// std::size_t and std::ptrdiff_t respectively. This makes us independant 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.
#include <typeinfo>
namespace __cxxabiv1
{
/* 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)
{ }
};
/* 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)
{ }
};
/* 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)
{ }
};
/* 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 __qualifier_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), __qualifier_flags (__quals), __pointee (__type)
{ }
/* implementation defined types */
public:
enum __qualifier_masks {
__const_mask = 0x1,
__volatile_mask = 0x2,
__restrict_mask = 0x4,
__incomplete_mask = 0x8,
__incomplete_class_mask = 0x10
};
/* 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)
{ }
/* implementation defined member functions */
protected:
virtual bool __is_pointer_p () const;
protected:
virtual bool __pointer_catch (const __pbase_type_info *__thr_type,
void **__thr_obj,
unsigned __outer) const;
};
/* type information for a pointer to member variable */
class __pointer_to_member_type_info
: public __pbase_type_info
{
/* abi defined member variables */
public:
__class_type_info *__context_class; /* 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_class (__klass)
{ }
/* implementation defined member functions */
protected:
virtual bool __pointer_catch (const __pbase_type_info *__thr_type,
void **__thr_obj,
unsigned __outer) const;
};
class __class_type_info;
/* helper class for __vmi_class_type */
class __base_class_info
{
/* abi defined member variables */
public:
const __class_type_info *__base; /* 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 */
};
/* 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)
{ }
/* 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
{
__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_info::__virtual_mask, /* via a virtual path */
__contained_public_mask = __base_class_info::__public_mask, /* via a public path */
__contained_mask = 1 << __base_class_info::hwm_bit, /* contained within us */
__contained_private = __contained_mask,
__contained_public = __contained_mask | __contained_public_mask
};
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)
{ }
/* 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 heirarchy */
unsigned int __base_count; /* number of direct bases */
__base_class_info const __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)
{ }
/* 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 */
non_public_base_mask = 0x4, /* has non-public direct or indirect base */
public_base_mask = 0x8, /* has public base (direct) */
__flags_unknown_mask = 0x10
};
/* 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 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__));
/* demangling routines */
extern "C"
char *__cxa_demangle (const char *__mangled_name,
char *__output_buffer,
__SIZE_TYPE__ *__length,
int *__status);
} /* namespace __cxxabiv1 */
/* User programs should use the alias `abi'. */
namespace abi = __cxxabiv1;
#else
#endif /* __cplusplus */
#endif /* __CXXABI_H */

65
libstdc++-v3/libsupc++/exception Normal file
View File

@ -0,0 +1,65 @@
// Exception Handling support header for -*- C++ -*-
// Copyright (C) 1995, 1996, 1997, 1998, 2000 Free Software Foundation
// This file is part of GNU CC.
//
// GNU CC is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2, or (at your option)
// any later version.
//
// GNU CC is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with GNU CC; see the file COPYING. If not, write to
// the Free Software Foundation, 59 Temple Place - Suite 330,
// Boston, MA 02111-1307, USA.
// As a special exception, you may use this file as part of a free software
// library without restriction. Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the GNU General Public License. This exception does not however
// invalidate any other reasons why the executable file might be covered by
// the GNU General Public License.
#ifndef __EXCEPTION__
#define __EXCEPTION__
#pragma interface "exception"
extern "C++" {
namespace std {
class exception {
public:
exception () { }
virtual ~exception () { }
virtual const char* what () const;
};
class bad_exception : public exception {
public:
bad_exception () { }
virtual ~bad_exception () { }
};
typedef void (*terminate_handler) ();
typedef void (*unexpected_handler) ();
terminate_handler set_terminate (terminate_handler);
void terminate () __attribute__ ((__noreturn__));
unexpected_handler set_unexpected (unexpected_handler);
void unexpected () __attribute__ ((__noreturn__));
bool uncaught_exception ();
} // namespace std
} // extern "C++"
#endif

69
libstdc++-v3/libsupc++/new Normal file
View File

@ -0,0 +1,69 @@
// The -*- C++ -*- dynamic memory management header.
// Copyright (C) 1994, 1996, 1997, 1998, 2000 Free Software Foundation
// This file is part of GNU CC.
//
// GNU CC is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2, or (at your option)
// any later version.
//
// GNU CC is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with GNU CC; see the file COPYING. If not, write to
// the Free Software Foundation, 59 Temple Place - Suite 330,
// Boston, MA 02111-1307, USA.
// As a special exception, you may use this file as part of a free software
// library without restriction. Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the GNU General Public License. This exception does not however
// invalidate any other reasons why the executable file might be covered by
// the GNU General Public License.
#ifndef __NEW__
#define __NEW__
#pragma interface "new"
#include <cstddef>
//#include <stddef.h>
#include <exception>
extern "C++" {
namespace std {
class bad_alloc : public exception {
public:
virtual const char* what() const throw() { return "bad_alloc"; }
};
struct nothrow_t {};
extern const nothrow_t nothrow;
typedef void (*new_handler)();
new_handler set_new_handler (new_handler);
} // namespace std
// replaceable signatures
void *operator new (size_t) throw (std::bad_alloc);
void *operator new[] (size_t) throw (std::bad_alloc);
void operator delete (void *) throw();
void operator delete[] (void *) throw();
void *operator new (size_t, const std::nothrow_t&) throw();
void *operator new[] (size_t, const std::nothrow_t&) throw();
void operator delete (void *, const std::nothrow_t&) throw();
void operator delete[] (void *, const std::nothrow_t&) throw();
// default placement versions of operator new
inline void *operator new(size_t, void *place) throw() { return place; }
inline void *operator new[](size_t, void *place) throw() { return place; }
} // extern "C++"
#endif

38
libstdc++-v3/libsupc++/new.h Normal file
View File

@ -0,0 +1,38 @@
// -*- C++ -*- forwarding header.
// Copyright (C) 2000 Free Software Foundation
// This file is part of GNU CC.
//
// GNU CC is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2, or (at your option)
// any later version.
//
// GNU CC is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with GNU CC; see the file COPYING. If not, write to
// the Free Software Foundation, 59 Temple Place - Suite 330,
// Boston, MA 02111-1307, USA.
// As a special exception, you may use this file as part of a free software
// library without restriction. Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the GNU General Public License. This exception does not however
// invalidate any other reasons why the executable file might be covered by
// the GNU General Public License.
#ifndef __NEW_H__
#define __NEW_H__
#include <new>
using std::new_handler;
using std::set_new_handler;
#endif // __NEW_H__

134
libstdc++-v3/libsupc++/typeinfo Normal file
View File

@ -0,0 +1,134 @@
// RTTI support for -*- C++ -*-
// Copyright (C) 1994, 1995, 1996, 1997, 1998, 2000 Free Software Foundation
// This file is part of GNU CC.
//
// GNU CC is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2, or (at your option)
// any later version.
//
// GNU CC is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with GNU CC; see the file COPYING. If not, write to
// the Free Software Foundation, 59 Temple Place - Suite 330,
// Boston, MA 02111-1307, USA.
// As a special exception, you may use this file as part of a free software
// library without restriction. Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the GNU General Public License. This exception does not however
// invalidate any other reasons why the executable file might be covered by
// the GNU General Public License.
// __GXX_ABI_VERSION distinguishes the ABI that is being used. Values <100
// indicate the `old' abi, which grew as C++ was defined. Values >=100
// indicate the `new' abi, which is a cross vendor C++ abi, documented at
// `http://reality.sgi.com/dehnert_engr/cxx/'.
#ifndef __TYPEINFO__
#define __TYPEINFO__
#pragma interface "typeinfo"
#include <exception>
extern "C++" {
#if defined(__GXX_ABI_VERSION) && __GXX_ABI_VERSION >= 100
namespace __cxxabiv1
{
class __class_type_info;
} // namespace __cxxabiv1
#endif
namespace std {
class type_info {
public:
// Destructor. Being the first non-inline virtual function, this controls in
// which translation unit the vtable is emitted. The compiler makes use of
// that information to know where to emit the runtime-mandated type_info
// structures in the new-abi.
virtual ~type_info ();
private:
// Assigning type_info is not supported. made private.
type_info& operator= (const type_info&);
type_info (const type_info&);
protected:
const char *__name;
protected:
explicit type_info (const char *__n): __name (__n) { }
public:
// the public interface
#if !defined(__GXX_ABI_VERSION) || __GXX_ABI_VERSION < 100
// In old abi, there can be multiple instances of a type_info object for one
// type. Uniqueness must use the _name value, not object address.
bool before (const type_info& arg) const;
const char* name () const
{ return __name; }
bool operator== (const type_info& __arg) const;
bool operator!= (const type_info& __arg) const
{ return !operator== (__arg); }
#else
// In new abi we can rely on type_info's NTBS being unique,
// and therefore address comparisons are sufficient.
bool before (const type_info& __arg) const
{ return __name < __arg.__name; }
const char* name () const
{ return __name; }
bool operator== (const type_info& __arg) const
{ return __name == __arg.__name; }
bool operator!= (const type_info& __arg) const
{ return !operator== (__arg); }
#endif
// the internal interface
#if defined(__GXX_ABI_VERSION) && __GXX_ABI_VERSION >= 100
public:
// return true if this is a pointer type of some kind
virtual bool __is_pointer_p () const;
// return true if this is a function type
virtual bool __is_function_p () const;
// Try and catch a thrown type. Store an adjusted pointer to the caught type
// in THR_OBJ. If THR_TYPE is not a pointer type, then THR_OBJ points to the
// thrown object. If THR_TYPE is a pointer type, then THR_OBJ is the pointer
// itself. OUTER indicates the number of outer pointers, and whether they
// were const qualified.
virtual bool __do_catch (const type_info *__thr_type, void **__thr_obj,
unsigned __outer) const;
// internally used during catch matching
virtual bool __do_upcast (const __cxxabiv1::__class_type_info *__target,
void **__obj_ptr) const;
#endif
};
class bad_cast : public exception {
public:
bad_cast() { }
virtual ~bad_cast() { }
};
class bad_typeid : public exception {
public:
bad_typeid () { }
virtual ~bad_typeid () { }
};
} // namespace std
} // extern "C++"
#endif