mirror of
https://github.com/reactos/reactos.git
synced 2024-08-28 22:28:36 +00:00
581 lines
19 KiB
C
581 lines
19 KiB
C
![]() |
/*
|
||
|
*
|
||
|
* Copyright (c) 1996,1997
|
||
|
* Silicon Graphics Computer Systems, Inc.
|
||
|
*
|
||
|
* Copyright (c) 1997
|
||
|
* Moscow Center for SPARC Technology
|
||
|
*
|
||
|
* Copyright (c) 1999
|
||
|
* Boris Fomitchev
|
||
|
*
|
||
|
* This material is provided "as is", with absolutely no warranty expressed
|
||
|
* or implied. Any use is at your own risk.
|
||
|
*
|
||
|
* Permission to use or copy this software for any purpose is hereby granted
|
||
|
* without fee, provided the above notices are retained on all copies.
|
||
|
* Permission to modify the code and to distribute modified code is granted,
|
||
|
* provided the above notices are retained, and a notice that the code was
|
||
|
* modified is included with the above copyright notice.
|
||
|
*
|
||
|
*/
|
||
|
|
||
|
/* NOTE: This is an internal header file, included by other STL headers.
|
||
|
* You should not attempt to use it directly.
|
||
|
*/
|
||
|
|
||
|
#ifndef _STLP_INTERNAL_ALLOC_H
|
||
|
#define _STLP_INTERNAL_ALLOC_H
|
||
|
|
||
|
#ifndef _STLP_INTERNAL_CSTDDEF
|
||
|
# include <stl/_cstddef.h>
|
||
|
#endif
|
||
|
|
||
|
#ifndef _STLP_INTERNAL_CSTDLIB
|
||
|
# include <stl/_cstdlib.h>
|
||
|
#endif
|
||
|
|
||
|
#ifndef _STLP_INTERNAL_CSTRING
|
||
|
# include <stl/_cstring.h>
|
||
|
#endif
|
||
|
|
||
|
#ifndef _STLP_INTERNAL_ALGOBASE_H
|
||
|
# include <stl/_algobase.h>
|
||
|
#endif
|
||
|
|
||
|
#ifndef _STLP_INTERNAL_NEW_HEADER
|
||
|
# include <stl/_new.h>
|
||
|
#endif
|
||
|
|
||
|
#ifndef _STLP_INTERNAL_CONSTRUCT_H
|
||
|
# include <stl/_construct.h>
|
||
|
#endif
|
||
|
|
||
|
_STLP_BEGIN_NAMESPACE
|
||
|
|
||
|
// Malloc-based allocator. Typically slower than default alloc below.
|
||
|
// Typically thread-safe and more storage efficient.
|
||
|
|
||
|
#if !defined (_STLP_USE_NO_IOSTREAMS)
|
||
|
typedef void (* __oom_handler_type)();
|
||
|
#endif
|
||
|
|
||
|
class _STLP_CLASS_DECLSPEC __malloc_alloc {
|
||
|
public:
|
||
|
// this one is needed for proper simple_alloc wrapping
|
||
|
typedef char value_type;
|
||
|
static void* _STLP_CALL allocate(size_t __n)
|
||
|
#if !defined (_STLP_USE_NO_IOSTREAMS)
|
||
|
;
|
||
|
#else
|
||
|
{
|
||
|
void *__result = malloc(__n);
|
||
|
if (__result == 0) {
|
||
|
_STLP_THROW_BAD_ALLOC;
|
||
|
}
|
||
|
return __result;
|
||
|
}
|
||
|
#endif
|
||
|
|
||
|
static void _STLP_CALL deallocate(void* __p, size_t /* __n */) { free((char*)__p); }
|
||
|
#if !defined (_STLP_USE_NO_IOSTREAMS)
|
||
|
static __oom_handler_type _STLP_CALL set_malloc_handler(__oom_handler_type __f);
|
||
|
#endif
|
||
|
};
|
||
|
|
||
|
// New-based allocator. Typically slower than default alloc below.
|
||
|
// Typically thread-safe and more storage efficient.
|
||
|
class _STLP_CLASS_DECLSPEC __new_alloc {
|
||
|
public:
|
||
|
// this one is needed for proper simple_alloc wrapping
|
||
|
typedef char value_type;
|
||
|
static void* _STLP_CALL allocate(size_t __n) { return __stl_new(__n); }
|
||
|
static void _STLP_CALL deallocate(void* __p, size_t) { __stl_delete(__p); }
|
||
|
};
|
||
|
|
||
|
// Allocator adaptor to check size arguments for debugging.
|
||
|
// Reports errors using assert. Checking can be disabled with
|
||
|
// NDEBUG, but it's far better to just use the underlying allocator
|
||
|
// instead when no checking is desired.
|
||
|
// There is some evidence that this can confuse Purify.
|
||
|
// This adaptor can only be applied to raw allocators
|
||
|
|
||
|
template <class _Alloc>
|
||
|
class __debug_alloc : public _Alloc {
|
||
|
public:
|
||
|
typedef _Alloc __allocator_type;
|
||
|
typedef typename _Alloc::value_type value_type;
|
||
|
private:
|
||
|
struct __alloc_header {
|
||
|
size_t __magic: 16;
|
||
|
size_t __type_size:16;
|
||
|
_STLP_UINT32_T _M_size;
|
||
|
}; // that is 8 bytes for sure
|
||
|
// Sunpro CC has bug on enums, so extra_before/after set explicitly
|
||
|
enum { __pad = 8, __magic = 0xdeba, __deleted_magic = 0xdebd,
|
||
|
__shred_byte = _STLP_SHRED_BYTE };
|
||
|
|
||
|
enum { __extra_before = 16, __extra_after = 8 };
|
||
|
// Size of space used to store size. Note
|
||
|
// that this must be large enough to preserve
|
||
|
// alignment.
|
||
|
static size_t _STLP_CALL __extra_before_chunk() {
|
||
|
return (long)__extra_before / sizeof(value_type) +
|
||
|
(size_t)((long)__extra_before % sizeof(value_type) > 0);
|
||
|
}
|
||
|
static size_t _STLP_CALL __extra_after_chunk() {
|
||
|
return (long)__extra_after / sizeof(value_type) +
|
||
|
(size_t)((long)__extra_after % sizeof(value_type) > 0);
|
||
|
}
|
||
|
public:
|
||
|
__debug_alloc() {}
|
||
|
~__debug_alloc() {}
|
||
|
static void* _STLP_CALL allocate(size_t);
|
||
|
static void _STLP_CALL deallocate(void *, size_t);
|
||
|
};
|
||
|
|
||
|
# if defined (__OS400__)
|
||
|
// dums 02/05/2007: is it really necessary ?
|
||
|
enum { _MAX_BYTES = 256 };
|
||
|
# else
|
||
|
enum { _MAX_BYTES = 32 * sizeof(void*) };
|
||
|
# endif
|
||
|
|
||
|
#if !defined (_STLP_USE_NO_IOSTREAMS)
|
||
|
// Default node allocator.
|
||
|
// With a reasonable compiler, this should be roughly as fast as the
|
||
|
// original STL class-specific allocators, but with less fragmentation.
|
||
|
class _STLP_CLASS_DECLSPEC __node_alloc {
|
||
|
static void * _STLP_CALL _M_allocate(size_t& __n);
|
||
|
/* __p may not be 0 */
|
||
|
static void _STLP_CALL _M_deallocate(void *__p, size_t __n);
|
||
|
|
||
|
public:
|
||
|
// this one is needed for proper simple_alloc wrapping
|
||
|
typedef char value_type;
|
||
|
/* __n must be > 0 */
|
||
|
static void* _STLP_CALL allocate(size_t& __n)
|
||
|
{ return (__n > (size_t)_MAX_BYTES) ? __stl_new(__n) : _M_allocate(__n); }
|
||
|
/* __p may not be 0 */
|
||
|
static void _STLP_CALL deallocate(void *__p, size_t __n)
|
||
|
{ if (__n > (size_t)_MAX_BYTES) __stl_delete(__p); else _M_deallocate(__p, __n); }
|
||
|
};
|
||
|
|
||
|
# if defined (_STLP_USE_TEMPLATE_EXPORT)
|
||
|
_STLP_EXPORT_TEMPLATE_CLASS __debug_alloc<__node_alloc>;
|
||
|
# endif
|
||
|
|
||
|
#endif
|
||
|
|
||
|
#if defined (_STLP_USE_TEMPLATE_EXPORT)
|
||
|
_STLP_EXPORT_TEMPLATE_CLASS __debug_alloc<__new_alloc>;
|
||
|
_STLP_EXPORT_TEMPLATE_CLASS __debug_alloc<__malloc_alloc>;
|
||
|
#endif
|
||
|
|
||
|
/* macro to convert the allocator for initialization
|
||
|
* not using MEMBER_TEMPLATE_CLASSES as it should work given template constructor */
|
||
|
#if defined (_STLP_MEMBER_TEMPLATES) || ! defined (_STLP_CLASS_PARTIAL_SPECIALIZATION)
|
||
|
/* if _STLP_NO_TEMPLATE_CONVERSIONS is set, the member template constructor is
|
||
|
* not used implicitly to convert allocator parameter, so let us do it explicitly */
|
||
|
# if defined (_STLP_MEMBER_TEMPLATE_CLASSES) && defined (_STLP_NO_TEMPLATE_CONVERSIONS)
|
||
|
# define _STLP_CONVERT_ALLOCATOR(__a, _Tp) __stl_alloc_create(__a,(_Tp*)0)
|
||
|
# else
|
||
|
# define _STLP_CONVERT_ALLOCATOR(__a, _Tp) __a
|
||
|
# endif
|
||
|
/* else convert, but only if partial specialization works, since else
|
||
|
* Container::allocator_type won't be different */
|
||
|
#else
|
||
|
# define _STLP_CONVERT_ALLOCATOR(__a, _Tp) __stl_alloc_create(__a,(_Tp*)0)
|
||
|
#endif
|
||
|
|
||
|
// Another allocator adaptor: _Alloc_traits. This serves two
|
||
|
// purposes. First, make it possible to write containers that can use
|
||
|
// either SGI-style allocators or standard-conforming allocator.
|
||
|
|
||
|
// The fully general version.
|
||
|
template <class _Tp, class _Allocator>
|
||
|
struct _Alloc_traits {
|
||
|
typedef _Allocator _Orig;
|
||
|
#if !defined (_STLP_DONT_SUPPORT_REBIND_MEMBER_TEMPLATE)
|
||
|
typedef typename _Allocator::_STLP_TEMPLATE rebind<_Tp> _Rebind_type;
|
||
|
typedef typename _Rebind_type::other allocator_type;
|
||
|
static allocator_type create_allocator(const _Orig& __a)
|
||
|
{ return allocator_type(_STLP_CONVERT_ALLOCATOR(__a, _Tp)); }
|
||
|
#else
|
||
|
// this is not actually true, used only to pass this type through
|
||
|
// to dynamic overload selection in _STLP_alloc_proxy methods
|
||
|
typedef _Allocator allocator_type;
|
||
|
#endif
|
||
|
};
|
||
|
|
||
|
#if defined (_STLP_USE_PERTHREAD_ALLOC)
|
||
|
|
||
|
_STLP_END_NAMESPACE
|
||
|
// include additional header here
|
||
|
# include <stl/_pthread_alloc.h>
|
||
|
_STLP_BEGIN_NAMESPACE
|
||
|
|
||
|
typedef __pthread_alloc __alloc_type;
|
||
|
#elif defined (_STLP_USE_NEWALLOC)
|
||
|
typedef __new_alloc __alloc_type;
|
||
|
#elif defined (_STLP_USE_MALLOC)
|
||
|
typedef __malloc_alloc __alloc_type;
|
||
|
#else
|
||
|
typedef __node_alloc __alloc_type;
|
||
|
#endif
|
||
|
|
||
|
#if defined (_STLP_DEBUG_ALLOC)
|
||
|
typedef __debug_alloc<__alloc_type> __sgi_alloc;
|
||
|
#else
|
||
|
typedef __alloc_type __sgi_alloc;
|
||
|
#endif
|
||
|
|
||
|
#if !defined (_STLP_NO_ANACHRONISMS)
|
||
|
typedef __sgi_alloc __single_client_alloc;
|
||
|
typedef __sgi_alloc __multithreaded_alloc;
|
||
|
#endif
|
||
|
|
||
|
// This implements allocators as specified in the C++ standard.
|
||
|
//
|
||
|
// Note that standard-conforming allocators use many language features
|
||
|
// that are not yet widely implemented. In particular, they rely on
|
||
|
// member templates, partial specialization, partial ordering of function
|
||
|
// templates, the typename keyword, and the use of the template keyword
|
||
|
// to refer to a template member of a dependent type.
|
||
|
|
||
|
/*
|
||
|
template <class _Tp>
|
||
|
struct _AllocatorAux {
|
||
|
typedef _Tp* pointer;
|
||
|
typedef const _Tp* const_pointer;
|
||
|
typedef _Tp& reference;
|
||
|
typedef const _Tp& const_reference;
|
||
|
|
||
|
pointer address(reference __x) const {return &__x;}
|
||
|
const_pointer address(const_reference __x) const { return &__x; }
|
||
|
};
|
||
|
|
||
|
template <class _Tp>
|
||
|
struct _AllocatorAux<const _Tp> {
|
||
|
typedef _Tp* pointer;
|
||
|
typedef const _Tp* const_pointer;
|
||
|
typedef _Tp& reference;
|
||
|
typedef const _Tp& const_reference;
|
||
|
|
||
|
const_pointer address(const_reference __x) const { return &__x; }
|
||
|
};
|
||
|
*/
|
||
|
|
||
|
template <class _Tp>
|
||
|
class allocator //: public _AllocatorAux<_Tp>
|
||
|
/* A small helper struct to recognize STLport allocator implementation
|
||
|
* from any user specialization one.
|
||
|
*/
|
||
|
: public __stlport_class<allocator<_Tp> >
|
||
|
{
|
||
|
public:
|
||
|
typedef _Tp value_type;
|
||
|
typedef _Tp* pointer;
|
||
|
typedef const _Tp* const_pointer;
|
||
|
typedef _Tp& reference;
|
||
|
typedef const _Tp& const_reference;
|
||
|
typedef size_t size_type;
|
||
|
typedef ptrdiff_t difference_type;
|
||
|
#if defined (_STLP_MEMBER_TEMPLATE_CLASSES)
|
||
|
template <class _Tp1> struct rebind {
|
||
|
typedef allocator<_Tp1> other;
|
||
|
};
|
||
|
#endif
|
||
|
allocator() _STLP_NOTHROW {}
|
||
|
#if defined (_STLP_MEMBER_TEMPLATES)
|
||
|
template <class _Tp1> allocator(const allocator<_Tp1>&) _STLP_NOTHROW {}
|
||
|
#endif
|
||
|
allocator(const allocator<_Tp>&) _STLP_NOTHROW {}
|
||
|
#if !defined (_STLP_NO_MOVE_SEMANTIC)
|
||
|
allocator(__move_source<allocator<_Tp> > src) _STLP_NOTHROW {}
|
||
|
#endif
|
||
|
~allocator() _STLP_NOTHROW {}
|
||
|
pointer address(reference __x) const {return &__x;}
|
||
|
const_pointer address(const_reference __x) const { return &__x; }
|
||
|
// __n is permitted to be 0. The C++ standard says nothing about what the return value is when __n == 0.
|
||
|
_Tp* allocate(size_type __n, const void* = 0) {
|
||
|
if (__n > max_size()) {
|
||
|
_STLP_THROW_BAD_ALLOC;
|
||
|
}
|
||
|
if (__n != 0) {
|
||
|
size_type __buf_size = __n * sizeof(value_type);
|
||
|
_Tp* __ret = __REINTERPRET_CAST(_Tp*, __sgi_alloc::allocate(__buf_size));
|
||
|
#if defined (_STLP_DEBUG_UNINITIALIZED) && !defined (_STLP_DEBUG_ALLOC)
|
||
|
memset((char*)__ret, _STLP_SHRED_BYTE, __buf_size);
|
||
|
#endif
|
||
|
return __ret;
|
||
|
}
|
||
|
|
||
|
return 0;
|
||
|
}
|
||
|
// __p is permitted to be a null pointer, only if n==0.
|
||
|
void deallocate(pointer __p, size_type __n) {
|
||
|
_STLP_ASSERT( (__p == 0) == (__n == 0) )
|
||
|
if (__p != 0) {
|
||
|
#if defined (_STLP_DEBUG_UNINITIALIZED) && !defined (_STLP_DEBUG_ALLOC)
|
||
|
memset((char*)__p, _STLP_SHRED_BYTE, __n * sizeof(value_type));
|
||
|
#endif
|
||
|
__sgi_alloc::deallocate((void*)__p, __n * sizeof(value_type));
|
||
|
}
|
||
|
}
|
||
|
#if !defined (_STLP_NO_ANACHRONISMS)
|
||
|
// backwards compatibility
|
||
|
void deallocate(pointer __p) const { if (__p != 0) __sgi_alloc::deallocate((void*)__p, sizeof(value_type)); }
|
||
|
#endif
|
||
|
size_type max_size() const _STLP_NOTHROW { return size_t(-1) / sizeof(value_type); }
|
||
|
void construct(pointer __p, const_reference __val) { _STLP_STD::_Copy_Construct(__p, __val); }
|
||
|
void destroy(pointer __p) { _STLP_STD::_Destroy(__p); }
|
||
|
|
||
|
#if defined (_STLP_NO_EXTENSIONS)
|
||
|
/* STLport extension giving rounded size of an allocated memory buffer
|
||
|
* This method do not have to be part of a user defined allocator implementation
|
||
|
* and won't even be called if such a function was granted.
|
||
|
*/
|
||
|
protected:
|
||
|
#endif
|
||
|
_Tp* _M_allocate(size_type __n, size_type& __allocated_n) {
|
||
|
if (__n > max_size()) {
|
||
|
_STLP_THROW_BAD_ALLOC;
|
||
|
}
|
||
|
|
||
|
if (__n != 0) {
|
||
|
size_type __buf_size = __n * sizeof(value_type);
|
||
|
_Tp* __ret = __REINTERPRET_CAST(_Tp*, __sgi_alloc::allocate(__buf_size));
|
||
|
#if defined (_STLP_DEBUG_UNINITIALIZED) && !defined (_STLP_DEBUG_ALLOC)
|
||
|
memset((char*)__ret, _STLP_SHRED_BYTE, __buf_size);
|
||
|
#endif
|
||
|
__allocated_n = __buf_size / sizeof(value_type);
|
||
|
return __ret;
|
||
|
}
|
||
|
|
||
|
return 0;
|
||
|
}
|
||
|
#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND) && !defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER)
|
||
|
void _M_swap_workaround(allocator<_Tp>& __other) {}
|
||
|
#endif
|
||
|
};
|
||
|
|
||
|
_STLP_TEMPLATE_NULL
|
||
|
class _STLP_CLASS_DECLSPEC allocator<void> {
|
||
|
public:
|
||
|
typedef size_t size_type;
|
||
|
typedef ptrdiff_t difference_type;
|
||
|
typedef void* pointer;
|
||
|
typedef const void* const_pointer;
|
||
|
#if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION)
|
||
|
typedef void value_type;
|
||
|
#endif
|
||
|
#if defined (_STLP_MEMBER_TEMPLATE_CLASSES)
|
||
|
template <class _Tp1> struct rebind {
|
||
|
typedef allocator<_Tp1> other;
|
||
|
};
|
||
|
#endif
|
||
|
};
|
||
|
|
||
|
template <class _T1, class _T2>
|
||
|
inline bool _STLP_CALL operator==(const allocator<_T1>&, const allocator<_T2>&) _STLP_NOTHROW
|
||
|
{ return true; }
|
||
|
template <class _T1, class _T2>
|
||
|
inline bool _STLP_CALL operator!=(const allocator<_T1>&, const allocator<_T2>&) _STLP_NOTHROW
|
||
|
{ return false; }
|
||
|
|
||
|
#if defined (_STLP_USE_TEMPLATE_EXPORT)
|
||
|
_STLP_EXPORT_TEMPLATE_CLASS allocator<char>;
|
||
|
# if defined (_STLP_HAS_WCHAR_T)
|
||
|
_STLP_EXPORT_TEMPLATE_CLASS allocator<wchar_t>;
|
||
|
# endif
|
||
|
# if defined (_STLP_USE_PTR_SPECIALIZATIONS)
|
||
|
_STLP_EXPORT_TEMPLATE_CLASS allocator<void*>;
|
||
|
# endif
|
||
|
#endif
|
||
|
|
||
|
_STLP_MOVE_TO_PRIV_NAMESPACE
|
||
|
|
||
|
template <class _Tp>
|
||
|
struct __alloc_type_traits {
|
||
|
#if !defined (__BORLANDC__)
|
||
|
typedef typename _IsSTLportClass<allocator<_Tp> >::_Ret _STLportAlloc;
|
||
|
#else
|
||
|
enum { _Is = _IsSTLportClass<allocator<_Tp> >::_Is };
|
||
|
typedef typename __bool2type<_Is>::_Ret _STLportAlloc;
|
||
|
#endif
|
||
|
//The default allocator implementation which is recognize thanks to the
|
||
|
//__stlport_class inheritance is a stateless object so:
|
||
|
typedef _STLportAlloc has_trivial_default_constructor;
|
||
|
typedef _STLportAlloc has_trivial_copy_constructor;
|
||
|
typedef _STLportAlloc has_trivial_assignment_operator;
|
||
|
typedef _STLportAlloc has_trivial_destructor;
|
||
|
typedef _STLportAlloc is_POD_type;
|
||
|
};
|
||
|
|
||
|
_STLP_MOVE_TO_STD_NAMESPACE
|
||
|
|
||
|
#if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION)
|
||
|
template <class _Tp>
|
||
|
struct __type_traits<allocator<_Tp> > : _STLP_PRIV __alloc_type_traits<_Tp> {};
|
||
|
#else
|
||
|
_STLP_TEMPLATE_NULL
|
||
|
struct __type_traits<allocator<char> > : _STLP_PRIV __alloc_type_traits<char> {};
|
||
|
# if defined (_STLP_HAS_WCHAR_T)
|
||
|
_STLP_TEMPLATE_NULL
|
||
|
struct __type_traits<allocator<wchar_t> > : _STLP_PRIV __alloc_type_traits<wchar_t> {};
|
||
|
# endif
|
||
|
# if defined (_STLP_USE_PTR_SPECIALIZATIONS)
|
||
|
_STLP_TEMPLATE_NULL
|
||
|
struct __type_traits<allocator<void*> > : _STLP_PRIV __alloc_type_traits<void*> {};
|
||
|
# endif
|
||
|
#endif
|
||
|
|
||
|
|
||
|
#if !defined (_STLP_FORCE_ALLOCATORS)
|
||
|
# define _STLP_FORCE_ALLOCATORS(a,y)
|
||
|
#endif
|
||
|
|
||
|
#if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION) && !defined (_STLP_MEMBER_TEMPLATE_CLASSES)
|
||
|
// The version for the default allocator, for rare occasion when we have partial spec w/o member template classes
|
||
|
template <class _Tp, class _Tp1>
|
||
|
struct _Alloc_traits<_Tp, allocator<_Tp1> > {
|
||
|
typedef allocator<_Tp1> _Orig;
|
||
|
typedef allocator<_Tp> allocator_type;
|
||
|
static allocator_type create_allocator(const allocator<_Tp1 >& __a)
|
||
|
{ return allocator_type(_STLP_CONVERT_ALLOCATOR(__a, _Tp)); }
|
||
|
};
|
||
|
#endif
|
||
|
|
||
|
#if !defined (_STLP_DONT_SUPPORT_REBIND_MEMBER_TEMPLATE) && defined (_STLP_MEMBER_TEMPLATES)
|
||
|
template <class _Tp, class _Alloc>
|
||
|
inline _STLP_TYPENAME_ON_RETURN_TYPE _Alloc_traits<_Tp, _Alloc>::allocator_type _STLP_CALL
|
||
|
__stl_alloc_create(const _Alloc& __a, const _Tp*) {
|
||
|
typedef typename _Alloc::_STLP_TEMPLATE rebind<_Tp>::other _Rebound_type;
|
||
|
return _Rebound_type(__a);
|
||
|
}
|
||
|
#else
|
||
|
// If custom allocators are being used without member template classes support :
|
||
|
// user (on purpose) is forced to define rebind/get operations !!!
|
||
|
template <class _Tp1, class _Tp2>
|
||
|
inline allocator<_Tp2>& _STLP_CALL
|
||
|
__stl_alloc_rebind(allocator<_Tp1>& __a, const _Tp2*) { return (allocator<_Tp2>&)(__a); }
|
||
|
template <class _Tp1, class _Tp2>
|
||
|
inline allocator<_Tp2> _STLP_CALL
|
||
|
__stl_alloc_create(const allocator<_Tp1>&, const _Tp2*) { return allocator<_Tp2>(); }
|
||
|
#endif
|
||
|
|
||
|
_STLP_MOVE_TO_PRIV_NAMESPACE
|
||
|
|
||
|
// inheritance is being used for EBO optimization
|
||
|
template <class _Value, class _Tp, class _MaybeReboundAlloc>
|
||
|
class _STLP_alloc_proxy : public _MaybeReboundAlloc {
|
||
|
private:
|
||
|
typedef _MaybeReboundAlloc _Base;
|
||
|
typedef typename _Base::size_type size_type;
|
||
|
typedef _STLP_alloc_proxy<_Value, _Tp, _MaybeReboundAlloc> _Self;
|
||
|
public:
|
||
|
_Value _M_data;
|
||
|
|
||
|
_STLP_alloc_proxy (const _MaybeReboundAlloc& __a, _Value __p) :
|
||
|
_MaybeReboundAlloc(__a), _M_data(__p) {}
|
||
|
|
||
|
#if !defined (_STLP_NO_MOVE_SEMANTIC)
|
||
|
_STLP_alloc_proxy (__move_source<_Self> src) :
|
||
|
_Base(_STLP_PRIV _AsMoveSource(src.get()._M_base())),
|
||
|
_M_data(_STLP_PRIV _AsMoveSource(src.get()._M_data)) {}
|
||
|
|
||
|
_Base& _M_base()
|
||
|
{ return *this; }
|
||
|
#endif
|
||
|
|
||
|
private:
|
||
|
/* Following are helper methods to detect stateless allocators and avoid
|
||
|
* swap in this case. For some compilers (VC6) it is a workaround for a
|
||
|
* compiler bug in the Empty Base class Optimization feature, for others
|
||
|
* it is a small optimization or nothing if no EBO. */
|
||
|
void _M_swap_alloc(_Self&, const __true_type& /*_IsStateless*/)
|
||
|
{}
|
||
|
|
||
|
void _M_swap_alloc(_Self& __x, const __false_type& /*_IsStateless*/) {
|
||
|
_MaybeReboundAlloc &__base_this = *this;
|
||
|
_MaybeReboundAlloc &__base_x = __x;
|
||
|
_STLP_STD::swap(__base_this, __base_x);
|
||
|
}
|
||
|
|
||
|
public:
|
||
|
void _M_swap_alloc(_Self& __x) {
|
||
|
#if !defined (__BORLANDC__)
|
||
|
typedef typename _IsStateless<_MaybeReboundAlloc>::_Ret _StatelessAlloc;
|
||
|
#else
|
||
|
typedef typename __bool2type<_IsStateless<_MaybeReboundAlloc>::_Is>::_Ret _StatelessAlloc;
|
||
|
#endif
|
||
|
_M_swap_alloc(__x, _StatelessAlloc());
|
||
|
}
|
||
|
|
||
|
/* We need to define the following swap implementation for allocator with state
|
||
|
* as those allocators might have implement a special swap function to correctly
|
||
|
* move datas from an instance to the oher, _STLP_alloc_proxy should not break
|
||
|
* this mecanism. */
|
||
|
void swap(_Self& __x) {
|
||
|
_M_swap_alloc(__x);
|
||
|
_STLP_STD::swap(_M_data, __x._M_data);
|
||
|
}
|
||
|
|
||
|
_Tp* allocate(size_type __n, size_type& __allocated_n) {
|
||
|
#if !defined (__BORLANDC__)
|
||
|
typedef typename _IsSTLportClass<_MaybeReboundAlloc>::_Ret _STLportAlloc;
|
||
|
#else
|
||
|
typedef typename __bool2type<_IsSTLportClass<_MaybeReboundAlloc>::_Is>::_Ret _STLportAlloc;
|
||
|
#endif
|
||
|
return allocate(__n, __allocated_n, _STLportAlloc());
|
||
|
}
|
||
|
|
||
|
// Unified interface to perform allocate()/deallocate() with limited
|
||
|
// language support
|
||
|
#if defined (_STLP_DONT_SUPPORT_REBIND_MEMBER_TEMPLATE)
|
||
|
// else it is rebound already, and allocate() member is accessible
|
||
|
_Tp* allocate(size_type __n)
|
||
|
{ return __stl_alloc_rebind(__STATIC_CAST(_Base&, *this), __STATIC_CAST(_Tp*, 0)).allocate(__n, 0); }
|
||
|
void deallocate(_Tp* __p, size_type __n)
|
||
|
{ __stl_alloc_rebind(__STATIC_CAST(_Base&, *this), __STATIC_CAST(_Tp*, 0)).deallocate(__p, __n); }
|
||
|
private:
|
||
|
_Tp* allocate(size_type __n, size_type& __allocated_n, const __true_type& /*STLport allocator*/)
|
||
|
{ return __stl_alloc_rebind(__STATIC_CAST(_Base&, *this), __STATIC_CAST(_Tp*, 0))._M_allocate(__n, __allocated_n); }
|
||
|
#else
|
||
|
//Expose Standard allocate overload (using expression do not work for some compilers (Borland))
|
||
|
_Tp* allocate(size_type __n)
|
||
|
{ return _Base::allocate(__n); }
|
||
|
private:
|
||
|
_Tp* allocate(size_type __n, size_type& __allocated_n, const __true_type& /*STLport allocator*/)
|
||
|
{ return _Base::_M_allocate(__n, __allocated_n); }
|
||
|
#endif
|
||
|
|
||
|
_Tp* allocate(size_type __n, size_type& __allocated_n, const __false_type& /*STLport allocator*/)
|
||
|
{ __allocated_n = __n; return allocate(__n); }
|
||
|
};
|
||
|
|
||
|
#if defined (_STLP_USE_TEMPLATE_EXPORT)
|
||
|
_STLP_EXPORT_TEMPLATE_CLASS _STLP_alloc_proxy<char*, char, allocator<char> >;
|
||
|
# if defined (_STLP_HAS_WCHAR_T)
|
||
|
_STLP_EXPORT_TEMPLATE_CLASS _STLP_alloc_proxy<wchar_t*, wchar_t, allocator<wchar_t> >;
|
||
|
# endif
|
||
|
# if defined (_STLP_USE_PTR_SPECIALIZATIONS)
|
||
|
_STLP_EXPORT_TEMPLATE_CLASS _STLP_alloc_proxy<void**, void*, allocator<void*> >;
|
||
|
# endif
|
||
|
#endif
|
||
|
|
||
|
_STLP_MOVE_TO_STD_NAMESPACE
|
||
|
_STLP_END_NAMESPACE
|
||
|
|
||
|
#if defined (_STLP_EXPOSE_GLOBALS_IMPLEMENTATION) && !defined (_STLP_LINK_TIME_INSTANTIATION)
|
||
|
# include <stl/_alloc.c>
|
||
|
#endif
|
||
|
|
||
|
#endif /* _STLP_INTERNAL_ALLOC_H */
|
||
|
|
||
|
// Local Variables:
|
||
|
// mode:C++
|
||
|
// End:
|
||
|
|