diff -r 666f914201fb -r 2fe1408b6811 epoc32/include/stdapis/stlport/stl/_alloc.h --- a/epoc32/include/stdapis/stlport/stl/_alloc.h Tue Nov 24 13:55:44 2009 +0000 +++ b/epoc32/include/stdapis/stlport/stl/_alloc.h Tue Mar 16 16:12:26 2010 +0000 @@ -1,1 +1,543 @@ -_alloc.h +/* + * + * 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_CSTDDEF +# include <cstddef> +# endif + +#if !defined (_STLP_DEBUG_H) && (defined (_STLP_DEBUG) || defined (_STLP_ASSERTIONS)) +# include <stl/debug/_debug.h> +#endif + +# ifndef _STLP_CSTDLIB +# include <cstdlib> +# endif +# ifndef _STLP_CSTRING +# include <cstring> +# endif + +# ifndef __THROW_BAD_ALLOC +# if !defined(_STLP_USE_EXCEPTIONS) +# if !defined (_STLP_CSTDIO) +# include <cstdio> +# endif +# if !defined (_STLP_CSTDLIB) +# include <cstdlib> +# endif +# define __THROW_BAD_ALLOC puts("out of memory\n"); exit(1) +# else /* !defined(_STLP_USE_EXCEPTIONS) */ +# define __THROW_BAD_ALLOC throw _STLP_STD::bad_alloc() +# endif /* !defined(_STLP_USE_EXCEPTIONS) */ +# endif /* __THROW_BAD_ALLOC */ + +# ifndef _STLP_INTERNAL_NEW_HEADER +# include <stl/_new.h> +# endif + +// #if ! defined (__SYMBIAN32__) +#if /* defined (_STLP_THREADS) && */ ! defined (_STLP_INTERNAL_THREADS_H) +# include <stl/_threads.h> +// #endif +#endif + +#ifndef _STLP_INTERNAL_CONSTRUCT_H +# include <stl/_construct.h> +#endif + +#ifndef __ALLOC +# define __ALLOC __sgi_alloc +#endif + +# ifndef __RESTRICT +# define __RESTRICT +# endif + +#if defined (_STLP_THREADS) || (defined(_STLP_OWN_IOSTREAMS) && ! defined (_STLP_NO_THREADS) && ! defined (_NOTHREADS) ) +# define _STLP_NODE_ALLOCATOR_THREADS true +#else +# define _STLP_NODE_ALLOCATOR_THREADS false +#endif + +_STLP_BEGIN_NAMESPACE + +# if defined (_STLP_USE_RAW_SGI_ALLOCATORS) +template <class _Tp, class _Alloc> struct __allocator; +# endif + +#ifndef _STLP_NO_NODE_ALLOC + +// Malloc-based allocator. Typically slower than default alloc below. +// Typically thread-safe and more storage efficient. + +typedef void (* __oom_handler_type)(); + +template <int __inst> +class __malloc_alloc { +private: + static void* _STLP_CALL _S_oom_malloc(size_t); + static __oom_handler_type __oom_handler; +public: + // this one is needed for proper simple_alloc wrapping + typedef char value_type; +# if defined (_STLP_MEMBER_TEMPLATE_CLASSES) && defined (_STLP_USE_RAW_SGI_ALLOCATORS) + template <class _Tp1> struct rebind { + typedef __allocator<_Tp1, __malloc_alloc<__inst> > other; + }; +# endif + static void* _STLP_CALL allocate(size_t __n) { + void* __result = malloc(__n); + if (0 == __result) __result = _S_oom_malloc(__n); + return __result; + } + static void _STLP_CALL deallocate(void* __p, size_t /* __n */) { free((char*)__p); } + static __oom_handler_type _STLP_CALL set_malloc_handler(__oom_handler_type __f) { + __oom_handler_type __old = __oom_handler; + __oom_handler = __f; + return(__old); + } +}; + +# 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; +# if defined (_STLP_MEMBER_TEMPLATE_CLASSES) && defined(_STLP_USE_RAW_SGI_ALLOCATORS) + template <class _Tp1> struct rebind { + typedef __allocator<_Tp1, __new_alloc > other; + }; +# endif + 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: +# if defined (_STLP_MEMBER_TEMPLATE_CLASSES) && defined (_STLP_USE_RAW_SGI_ALLOCATORS) + template <class _Tp1> struct rebind { + typedef __allocator< _Tp1, __debug_alloc<_Alloc> > other; + }; +# endif + __debug_alloc() {} + ~__debug_alloc() {} + static void * _STLP_CALL allocate(size_t); + static void _STLP_CALL deallocate(void *, size_t); +}; + +# if defined(__OS400__) +enum {_ALIGN = 16, _ALIGN_SHIFT=4, _MAX_BYTES = 256}; +# define _STLP_NFREELISTS 16 +# else +enum {_ALIGN = 8, _ALIGN_SHIFT=3, _MAX_BYTES = 128}; +# define _STLP_NFREELISTS 16 +# endif /* __OS400__ */ + +#ifndef _STLP_NO_NODE_ALLOC + +// Default node allocator. +// With a reasonable compiler, this should be roughly as fast as the +// original STL class-specific allocators, but with less fragmentation. +// Default_alloc_template parameters are experimental and MAY +// DISAPPEAR in the future. Clients should just use alloc for now. +// +// Important implementation properties: +// 1. If the client request an object of size > _MAX_BYTES, the resulting +// object will be obtained directly from malloc. +// 2. In all other cases, we allocate an object of size exactly +// _S_round_up(requested_size). Thus the client has enough size +// information that we can return the object to the proper free list +// without permanently losing part of the object. +// + +// The first template parameter specifies whether more than one thread +// may use this allocator. It is safe to allocate an object from +// one instance of a default_alloc and deallocate it with another +// one. This effectively transfers its ownership to the second one. +// This may have undesirable effects on reference locality. +// The second parameter is unreferenced and serves only to allow the +// creation of multiple default_alloc instances. + +class _STLP_CLASS_DECLSPEC _Node_alloc_obj { +public: + _Node_alloc_obj * _M_free_list_link; +}; + +template <bool __threads, int __inst> +class __node_alloc { + _STLP_PRIVATE: + static inline size_t _STLP_CALL _S_round_up(size_t __bytes) { return (((__bytes) + (size_t)_ALIGN-1) & ~((size_t)_ALIGN - 1)); } + typedef _Node_alloc_obj _Obj; +private: + // Returns an object of size __n, and optionally adds to size __n free list. + static void* _STLP_CALL _S_refill(size_t __n); + // Allocates a chunk for nobjs of size size. nobjs may be reduced + // if it is inconvenient to allocate the requested number. + static char* _STLP_CALL _S_chunk_alloc(size_t __p_size, int& __nobjs); + // Chunk allocation state. + static _Node_alloc_obj * _STLP_VOLATILE _S_free_list[_STLP_NFREELISTS]; + static char* _S_start_free; + static char* _S_end_free; + static size_t _S_heap_size; + 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; +# if defined (_STLP_MEMBER_TEMPLATE_CLASSES) && defined (_STLP_USE_RAW_SGI_ALLOCATORS) + template <class _Tp1> struct rebind { + typedef __allocator<_Tp1, __node_alloc<__threads, __inst> > other; + }; +# endif + /* __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 __malloc_alloc<0>; +_STLP_EXPORT_TEMPLATE_CLASS __node_alloc<_STLP_NODE_ALLOCATOR_THREADS, 0>; +# endif /* _STLP_USE_TEMPLATE_EXPORT */ +typedef __node_alloc<_STLP_NODE_ALLOCATOR_THREADS, 0> _Node_alloc; +# if defined (_STLP_USE_TEMPLATE_EXPORT) +_STLP_EXPORT_TEMPLATE_CLASS __debug_alloc<_Node_alloc>; +_STLP_EXPORT_TEMPLATE_CLASS __debug_alloc<__new_alloc>; +_STLP_EXPORT_TEMPLATE_CLASS __debug_alloc<__malloc_alloc<0> >; +# endif + +#endif + +# if defined (_STLP_USE_PERTHREAD_ALLOC) + +_STLP_END_NAMESPACE +// include additional header here +# include <stl/_pthread_alloc.h> +_STLP_BEGIN_NAMESPACE + +# if defined ( _STLP_DEBUG_ALLOC ) +typedef __debug_alloc<__pthread_alloc> __sgi_alloc; +# else +typedef __pthread_alloc __sgi_alloc; +# endif /* _STLP_DEBUG_ALLOC */ + +typedef __pthread_alloc __single_client_alloc; +typedef __pthread_alloc __multithreaded_alloc; + +# else + +# if defined ( _STLP_USE_NEWALLOC ) + +# if defined ( _STLP_DEBUG_ALLOC ) +typedef __debug_alloc<__new_alloc> __sgi_alloc; +# else +typedef __new_alloc __sgi_alloc; +# endif /* _STLP_DEBUG_ALLOC */ + +typedef __new_alloc __single_client_alloc; +typedef __new_alloc __multithreaded_alloc; + +# elif defined (_STLP_USE_MALLOC) + +# if defined ( _STLP_DEBUG_ALLOC ) +typedef __debug_alloc<__malloc_alloc<0> > __sgi_alloc; +# else +typedef __malloc_alloc<0> __sgi_alloc; +# endif /* _STLP_DEBUG_ALLOC */ + +typedef __malloc_alloc<0> __single_client_alloc; +typedef __malloc_alloc<0> __multithreaded_alloc; + +# else + +# if defined ( _STLP_DEBUG_ALLOC ) +typedef __debug_alloc<_Node_alloc> __sgi_alloc; +# else +typedef _Node_alloc __sgi_alloc; +# endif + +typedef __node_alloc<false, 0> __single_client_alloc; +typedef __node_alloc<true, 0> __multithreaded_alloc; + +# endif /* _STLP_USE_NEWALLOC */ +# endif /* PTHREAD_ALLOC */ + +// 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> +class allocator { +public: + + typedef _Tp value_type; + typedef value_type * 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 {} + ~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) { + return __n != 0 ? __REINTERPRET_CAST(value_type*,__sgi_alloc::allocate(__n * sizeof(value_type))) : 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) __sgi_alloc::deallocate((void*)__p, __n * sizeof(value_type)); + } + // backwards compatibility + void deallocate(pointer __p) const { if (__p != 0) __sgi_alloc::deallocate((void*)__p, sizeof(value_type)); } + size_type max_size() const _STLP_NOTHROW { return size_t(-1) / sizeof(value_type); } + void construct(pointer __p, const _Tp& __val) { _STLP_STD::_Construct(__p, __val); } + void destroy(pointer __p) { _STLP_STD::_Destroy(__p); } +# if defined(__MRC__)||(defined(__SC__) && !defined(__DMC__)) + template <class _T2> bool operator==(const allocator<_T2>&) const _STLP_NOTHROW { return true; } + template <class _T2> bool operator!=(const allocator<_T2>&) const _STLP_NOTHROW { return false; } +# 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 +# if defined(__MRC__)||(defined(__SC__)&&!defined(__DMC__)) //*ty 03/24/2001 - MPW compilers get confused on these operator definitions + template <class _T2> bool operator==(const allocator<_T2>&) const _STLP_NOTHROW { return true; } + template <class _T2> bool operator!=(const allocator<_T2>&) const _STLP_NOTHROW { return false; } +# endif +}; + +#if !(defined(__MRC__)||(defined(__SC__)&&!defined(__DMC__))) //*ty 03/24/2001 - MPW compilers get confused on these operator definitions +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; } +#endif + +# 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 +# endif /* _STLP_USE_TEMPLATE_EXPORT */ + +// 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_USE_NESTED_TCLASS_THROUGHT_TPARAM) + 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(__a); } +# 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 /* _STLP_USE_NESTED_TCLASS_THROUGHT_TPARAM */ +}; + +#ifndef _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(__a); } +}; +#endif /* _STLP_CLASS_PARTIAL_SPECIALIZATION */ + +/* 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 + +# if defined (_STLP_USE_NESTED_TCLASS_THROUGHT_TPARAM) +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_USE_NESTED_TCLASS_THROUGHT_TPARAM */ + +# ifdef _STLP_USE_RAW_SGI_ALLOCATORS +// move obsolete stuff out of the way +# include <stl/_alloc_old.h> +# endif + +// 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 _STLP_alloc_proxy<_Value, _Tp, _MaybeReboundAlloc> _Self; +public: + _Value _M_data; + inline _STLP_alloc_proxy(const _MaybeReboundAlloc& __a, _Value __p) : _MaybeReboundAlloc(__a), _M_data(__p) {} + +# if 0 + inline _STLP_alloc_proxy(const _Self& __x) : _MaybeReboundAlloc(__x), _M_data(__x._M_data) {} + // construction/destruction + inline _Self& operator = (const _Self& __x) { + *(_MaybeReboundAlloc*)this = *(_MaybeReboundAlloc*)__x; + _M_data = __x._M_data; return *this; + } + inline _Self& operator = (const _Base& __x) { ((_Base&)*this) = __x; return *this; } +# endif + // Unified interface to perform allocate()/deallocate() with limited + // language support +#if ! defined (_STLP_USE_NESTED_TCLASS_THROUGHT_TPARAM) + // else it is rebound already, and allocate() member is accessible + inline _Tp* allocate(size_t __n) { + return __stl_alloc_rebind(__STATIC_CAST(_Base&,*this),(_Tp*)0).allocate(__n,0); + } + inline void deallocate(_Tp* __p, size_t __n) { + __stl_alloc_rebind(__STATIC_CAST(_Base&, *this),(_Tp*)0).deallocate(__p, __n); + } +#endif /* !_STLP_USE_NESTED_TCLASS_THROUGHT_TPARAM */ +}; + +# 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 +# endif /* _STLP_USE_TEMPLATE_EXPORT */ + +# undef _STLP_NODE_ALLOCATOR_THREADS + +_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: +