ndk/sources/cxx-stl/stlport/stlport/stl/_alloc.h

   1 /*
   2  *
   3  * Copyright (c) 1996,1997
   4  * Silicon Graphics Computer Systems, Inc.
   5  *
   6  * Copyright (c) 1997
   7  * Moscow Center for SPARC Technology
   8  *
   9  * Copyright (c) 1999
  10  * Boris Fomitchev
  11  *
  12  * This material is provided "as is", with absolutely no warranty expressed
  13  * or implied. Any use is at your own risk.
  14  *
  15  * Permission to use or copy this software for any purpose is hereby granted
  16  * without fee, provided the above notices are retained on all copies.
  17  * Permission to modify the code and to distribute modified code is granted,
  18  * provided the above notices are retained, and a notice that the code was
  19  * modified is included with the above copyright notice.
  20  *
  21  */
  22
  23 /* NOTE: This is an internal header file, included by other STL headers.
  24  *   You should not attempt to use it directly.
  25  */
  26
  27 #ifndef _STLP_INTERNAL_ALLOC_H
  28 #define _STLP_INTERNAL_ALLOC_H
  29
  30 #ifndef _STLP_INTERNAL_CSTDDEF
  31 #  include <stl/_cstddef.h>
  32 #endif
  33
  34 #ifndef _STLP_INTERNAL_CSTDLIB
  35 #  include <stl/_cstdlib.h>
  36 #endif
  37
  38 #ifndef _STLP_INTERNAL_CSTRING
  39 #  include <stl/_cstring.h>
  40 #endif
  41
  42 #ifndef _STLP_INTERNAL_ALGOBASE_H
  43 #  include <stl/_algobase.h>
  44 #endif
  45
  46 #ifndef _STLP_INTERNAL_NEW_HEADER
  47 #  include <stl/_new.h>
  48 #endif
  49
  50 #ifndef _STLP_INTERNAL_CONSTRUCT_H
  51 #  include <stl/_construct.h>
  52 #endif
  53
  54 _STLP_BEGIN_NAMESPACE
  55
  56 // Malloc-based allocator.  Typically slower than default alloc below.
  57 // Typically thread-safe and more storage efficient.
  58
  59 #if !defined (_STLP_USE_NO_IOSTREAMS)
  60 typedef void (* __oom_handler_type)();
  61 #endif
  62
  63 class _STLP_CLASS_DECLSPEC __malloc_alloc {
  64 public:
  65   // this one is needed for proper simple_alloc wrapping
  66   typedef char value_type;
  67   static void* _STLP_CALL allocate(size_t __n)
  68 #if !defined (_STLP_USE_NO_IOSTREAMS)
  69   ;
  70 #else
  71   {
  72     void *__result = malloc(__n);
  73     if (__result == 0) {
  74       _STLP_THROW_BAD_ALLOC;
  75     }
  76     return __result;
  77   }
  78 #endif
  79
  80   static void _STLP_CALL deallocate(void* __p, size_t /* __n */) { free((char*)__p); }
  81 #if !defined (_STLP_USE_NO_IOSTREAMS)
  82   static __oom_handler_type _STLP_CALL set_malloc_handler(__oom_handler_type __f);
  83 #endif
  84 };
  85
  86 // New-based allocator.  Typically slower than default alloc below.
  87 // Typically thread-safe and more storage efficient.
  88 class _STLP_CLASS_DECLSPEC __new_alloc {
  89 public:
  90   // this one is needed for proper simple_alloc wrapping
  91   typedef char value_type;
  92   static void* _STLP_CALL allocate(size_t __n) { return __stl_new(__n); }
  93   static void _STLP_CALL deallocate(void* __p, size_t) { __stl_delete(__p); }
  94 };
  95
  96 // Allocator adaptor to check size arguments for debugging.
  97 // Reports errors using assert.  Checking can be disabled with
  98 // NDEBUG, but it's far better to just use the underlying allocator
  99 // instead when no checking is desired.
 100 // There is some evidence that this can confuse Purify.
 101 // This adaptor can only be applied to raw allocators
 102
 103 template <class _Alloc>
 104 class __debug_alloc : public _Alloc {
 105 public:
 106   typedef _Alloc __allocator_type;
 107   typedef typename _Alloc::value_type value_type;
 108 private:
 109   struct __alloc_header {
 110     size_t __magic: 16;
 111     size_t __type_size:16;
 112     _STLP_UINT32_T _M_size;
 113   }; // that is 8 bytes for sure
 114   // Sunpro CC has bug on enums, so extra_before/after set explicitly
 115   enum { __pad = 8, __magic = 0xdeba, __deleted_magic = 0xdebd,
 116          __shred_byte = _STLP_SHRED_BYTE };
 117
 118   enum { __extra_before = 16, __extra_after = 8 };
 119   // Size of space used to store size.  Note
 120   // that this must be large enough to preserve
 121   // alignment.
 122   static size_t _STLP_CALL __extra_before_chunk() {
 123     return (long)__extra_before / sizeof(value_type) +
 124       (size_t)((long)__extra_before % sizeof(value_type) > 0);
 125   }
 126   static size_t _STLP_CALL __extra_after_chunk() {
 127     return (long)__extra_after / sizeof(value_type) +
 128       (size_t)((long)__extra_after % sizeof(value_type) > 0);
 129   }
 130 public:
 131   __debug_alloc() {}
 132   ~__debug_alloc() {}
 133   static void* _STLP_CALL allocate(size_t);
 134   static void _STLP_CALL deallocate(void *, size_t);
 135 };
 136
 137 #  if defined (__OS400__)
 138 // dums 02/05/2007: is it really necessary ?
 139 enum { _MAX_BYTES = 256 };
 140 #  else
 141 enum { _MAX_BYTES = 32 * sizeof(void*) };
 142 #  endif
 143
 144 #if !defined (_STLP_USE_NO_IOSTREAMS)
 145 // Default node allocator.
 146 // With a reasonable compiler, this should be roughly as fast as the
 147 // original STL class-specific allocators, but with less fragmentation.
 148 class _STLP_CLASS_DECLSPEC __node_alloc {
 149   static void * _STLP_CALL _M_allocate(size_t& __n);
 150   /* __p may not be 0 */
 151   static void _STLP_CALL _M_deallocate(void *__p, size_t __n);
 152
 153 public:
 154   // this one is needed for proper simple_alloc wrapping
 155   typedef char value_type;
 156   /* __n must be > 0      */
 157   static void* _STLP_CALL allocate(size_t& __n)
 158   { return (__n > (size_t)_MAX_BYTES) ? __stl_new(__n) : _M_allocate(__n); }
 159   /* __p may not be 0 */
 160   static void _STLP_CALL deallocate(void *__p, size_t __n)
 161   { if (__n > (size_t)_MAX_BYTES) __stl_delete(__p); else _M_deallocate(__p, __n); }
 162 };
 163
 164 #  if defined (_STLP_USE_TEMPLATE_EXPORT)
 165 _STLP_EXPORT_TEMPLATE_CLASS __debug_alloc<__node_alloc>;
 166 #  endif
 167
 168 #endif
 169
 170 #if defined (_STLP_USE_TEMPLATE_EXPORT)
 171 _STLP_EXPORT_TEMPLATE_CLASS __debug_alloc<__new_alloc>;
 172 _STLP_EXPORT_TEMPLATE_CLASS __debug_alloc<__malloc_alloc>;
 173 #endif
 174
 175 /* macro to convert the allocator for initialization
 176  * not using MEMBER_TEMPLATE_CLASSES as it should work given template constructor  */
 177 #if defined (_STLP_MEMBER_TEMPLATES) || ! defined (_STLP_CLASS_PARTIAL_SPECIALIZATION)
 178 /* if _STLP_NO_TEMPLATE_CONVERSIONS is set, the member template constructor is
 179  * not used implicitly to convert allocator parameter, so let us do it explicitly */
 180 #  if defined (_STLP_MEMBER_TEMPLATE_CLASSES) && defined (_STLP_NO_TEMPLATE_CONVERSIONS)
 181 #    define _STLP_CONVERT_ALLOCATOR(__a, _Tp) __stl_alloc_create(__a,(_Tp*)0)
 182 #  else
 183 #    define _STLP_CONVERT_ALLOCATOR(__a, _Tp) __a
 184 #  endif
 185 /* else convert, but only if partial specialization works, since else
 186  * Container::allocator_type won't be different */
 187 #else
 188 #  define _STLP_CONVERT_ALLOCATOR(__a, _Tp) __stl_alloc_create(__a,(_Tp*)0)
 189 #endif
 190
 191 // Another allocator adaptor: _Alloc_traits.  This serves two
 192 // purposes.  First, make it possible to write containers that can use
 193 // either SGI-style allocators or standard-conforming allocator.
 194
 195 // The fully general version.
 196 template <class _Tp, class _Allocator>
 197 struct _Alloc_traits {
 198   typedef _Allocator _Orig;
 199 #if !defined (_STLP_DONT_SUPPORT_REBIND_MEMBER_TEMPLATE)
 200   typedef typename _Allocator::_STLP_TEMPLATE rebind<_Tp> _Rebind_type;
 201   typedef typename _Rebind_type::other  allocator_type;
 202   static allocator_type create_allocator(const _Orig& __a)
 203   { return allocator_type(_STLP_CONVERT_ALLOCATOR(__a, _Tp)); }
 204 #else
 205   // this is not actually true, used only to pass this type through
 206   // to dynamic overload selection in _STLP_alloc_proxy methods
 207   typedef _Allocator allocator_type;
 208 #endif
 209 };
 210
 211 #if defined (_STLP_USE_PERTHREAD_ALLOC)
 212
 213 _STLP_END_NAMESPACE
 214 // include additional header here
 215 #  include <stl/_pthread_alloc.h>
 216 _STLP_BEGIN_NAMESPACE
 217
 218 typedef __pthread_alloc __alloc_type;
 219 #elif defined (_STLP_USE_NEWALLOC)
 220 typedef __new_alloc __alloc_type;
 221 #elif defined (_STLP_USE_MALLOC)
 222 typedef __malloc_alloc __alloc_type;
 223 #else
 224 typedef __node_alloc __alloc_type;
 225 #endif
 226
 227 #if defined (_STLP_DEBUG_ALLOC)
 228 typedef __debug_alloc<__alloc_type> __sgi_alloc;
 229 #else
 230 typedef __alloc_type __sgi_alloc;
 231 #endif
 232
 233 #if !defined (_STLP_NO_ANACHRONISMS)
 234 typedef __sgi_alloc __single_client_alloc;
 235 typedef __sgi_alloc __multithreaded_alloc;
 236 #endif
 237
 238 // This implements allocators as specified in the C++ standard.
 239 //
 240 // Note that standard-conforming allocators use many language features
 241 // that are not yet widely implemented.  In particular, they rely on
 242 // member templates, partial specialization, partial ordering of function
 243 // templates, the typename keyword, and the use of the template keyword
 244 // to refer to a template member of a dependent type.
 245
 246 /*
 247 template <class _Tp>
 248 struct _AllocatorAux {
 249   typedef _Tp*       pointer;
 250   typedef const _Tp* const_pointer;
 251   typedef _Tp&       reference;
 252   typedef const _Tp& const_reference;
 253
 254   pointer address(reference __x) const {return &__x;}
 255   const_pointer address(const_reference __x) const { return &__x; }
 256 };
 257
 258 template <class _Tp>
 259 struct _AllocatorAux<const _Tp> {
 260   typedef _Tp*       pointer;
 261   typedef const _Tp* const_pointer;
 262   typedef _Tp&       reference;
 263   typedef const _Tp& const_reference;
 264
 265   const_pointer address(const_reference __x) const { return &__x; }
 266 };
 267 */
 268
 269 template <class _Tp>
 270 class allocator //: public _AllocatorAux<_Tp>
 271 /* A small helper struct to recognize STLport allocator implementation
 272  * from any user specialization one.
 273  */
 274                 : public __stlport_class<allocator<_Tp> >
 275 {
 276 public:
 277   typedef _Tp        value_type;
 278   typedef _Tp*       pointer;
 279   typedef const _Tp* const_pointer;
 280   typedef _Tp&       reference;
 281   typedef const _Tp& const_reference;
 282   typedef size_t     size_type;
 283   typedef ptrdiff_t  difference_type;
 284 #if defined (_STLP_MEMBER_TEMPLATE_CLASSES)
 285   template <class _Tp1> struct rebind {
 286     typedef allocator<_Tp1> other;
 287   };
 288 #endif
 289   allocator() _STLP_NOTHROW {}
 290 #if defined (_STLP_MEMBER_TEMPLATES)
 291   template <class _Tp1> allocator(const allocator<_Tp1>&) _STLP_NOTHROW {}
 292 #endif
 293   allocator(const allocator<_Tp>&) _STLP_NOTHROW {}
 294 #if !defined (_STLP_NO_MOVE_SEMANTIC)
 295   allocator(__move_source<allocator<_Tp> > src) _STLP_NOTHROW {}
 296 #endif
 297   ~allocator() _STLP_NOTHROW {}
 298   pointer address(reference __x) const {return &__x;}
 299   const_pointer address(const_reference __x) const { return &__x; }
 300   // __n is permitted to be 0.  The C++ standard says nothing about what the return value is when __n == 0.
 301   _Tp* allocate(size_type __n, const void* = 0) {
 302     if (__n > max_size()) {
 303       _STLP_THROW_BAD_ALLOC;
 304     }
 305     if (__n != 0) {
 306       size_type __buf_size = __n * sizeof(value_type);
 307       _Tp* __ret = __REINTERPRET_CAST(_Tp*, __sgi_alloc::allocate(__buf_size));
 308 #if defined (_STLP_DEBUG_UNINITIALIZED) && !defined (_STLP_DEBUG_ALLOC)
 309       memset((char*)__ret, _STLP_SHRED_BYTE, __buf_size);
 310 #endif
 311       return __ret;
 312     }
 313
 314     return 0;
 315   }
 316   // __p is permitted to be a null pointer, only if n==0.
 317   void deallocate(pointer __p, size_type __n) {
 318     _STLP_ASSERT( (__p == 0) == (__n == 0) )
 319     if (__p != 0) {
 320 #if defined (_STLP_DEBUG_UNINITIALIZED) && !defined (_STLP_DEBUG_ALLOC)
 321       memset((char*)__p, _STLP_SHRED_BYTE, __n * sizeof(value_type));
 322 #endif
 323       __sgi_alloc::deallocate((void*)__p, __n * sizeof(value_type));
 324     }
 325   }
 326 #if !defined (_STLP_NO_ANACHRONISMS)
 327   // backwards compatibility
 328   void deallocate(pointer __p) const {  if (__p != 0) __sgi_alloc::deallocate((void*)__p, sizeof(value_type)); }
 329 #endif
 330   size_type max_size() const _STLP_NOTHROW  { return size_t(-1) / sizeof(value_type); }
 331   void construct(pointer __p, const_reference __val) { _STLP_STD::_Copy_Construct(__p, __val); }
 332   void destroy(pointer __p) { _STLP_STD::_Destroy(__p); }
 333
 334 #if defined (_STLP_NO_EXTENSIONS)
 335   /* STLport extension giving rounded size of an allocated memory buffer
 336    * This method do not have to be part of a user defined allocator implementation
 337    * and won't even be called if such a function was granted.
 338    */
 339 protected:
 340 #endif
 341   _Tp* _M_allocate(size_type __n, size_type& __allocated_n) {
 342     if (__n > max_size()) {
 343       _STLP_THROW_BAD_ALLOC;
 344     }
 345
 346     if (__n != 0) {
 347       size_type __buf_size = __n * sizeof(value_type);
 348       _Tp* __ret = __REINTERPRET_CAST(_Tp*, __sgi_alloc::allocate(__buf_size));
 349 #if defined (_STLP_DEBUG_UNINITIALIZED) && !defined (_STLP_DEBUG_ALLOC)
 350       memset((char*)__ret, _STLP_SHRED_BYTE, __buf_size);
 351 #endif
 352       __allocated_n = __buf_size / sizeof(value_type);
 353       return __ret;
 354     }
 355
 356     return 0;
 357   }
 358 #if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND) && !defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER)
 359   void _M_swap_workaround(allocator<_Tp>& __other) {}
 360 #endif
 361 };
 362
 363 _STLP_TEMPLATE_NULL
 364 class _STLP_CLASS_DECLSPEC allocator<void> {
 365 public:
 366   typedef size_t      size_type;
 367   typedef ptrdiff_t   difference_type;
 368   typedef void*       pointer;
 369   typedef const void* const_pointer;
 370 #if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION)
 371   typedef void        value_type;
 372 #endif
 373 #if defined (_STLP_MEMBER_TEMPLATE_CLASSES)
 374   template <class _Tp1> struct rebind {
 375     typedef allocator<_Tp1> other;
 376   };
 377 #endif
 378 };
 379
 380 template <class _T1, class _T2>
 381 inline bool _STLP_CALL operator==(const allocator<_T1>&, const allocator<_T2>&) _STLP_NOTHROW
 382 { return true; }
 383 template <class _T1, class _T2>
 384 inline bool _STLP_CALL operator!=(const allocator<_T1>&, const allocator<_T2>&) _STLP_NOTHROW
 385 { return false; }
 386
 387 #if defined (_STLP_USE_TEMPLATE_EXPORT)
 388 _STLP_EXPORT_TEMPLATE_CLASS allocator<char>;
 389 #  if defined (_STLP_HAS_WCHAR_T)
 390 _STLP_EXPORT_TEMPLATE_CLASS allocator<wchar_t>;
 391 #  endif
 392 #  if defined (_STLP_USE_PTR_SPECIALIZATIONS)
 393 _STLP_EXPORT_TEMPLATE_CLASS allocator<void*>;
 394 #  endif
 395 #endif
 396
 397 _STLP_MOVE_TO_PRIV_NAMESPACE
 398
 399 template <class _Tp>
 400 struct __alloc_type_traits {
 401 #if !defined (__BORLANDC__)
 402   typedef typename _IsSTLportClass<allocator<_Tp> >::_Ret _STLportAlloc;
 403 #else
 404   enum { _Is = _IsSTLportClass<allocator<_Tp> >::_Is };
 405   typedef typename __bool2type<_Is>::_Ret _STLportAlloc;
 406 #endif
 407   //The default allocator implementation which is recognize thanks to the
 408   //__stlport_class inheritance is a stateless object so:
 409   typedef _STLportAlloc has_trivial_default_constructor;
 410   typedef _STLportAlloc has_trivial_copy_constructor;
 411   typedef _STLportAlloc has_trivial_assignment_operator;
 412   typedef _STLportAlloc has_trivial_destructor;
 413   typedef _STLportAlloc is_POD_type;
 414 };
 415
 416 _STLP_MOVE_TO_STD_NAMESPACE
 417
 418 #if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION)
 419 template <class _Tp>
 420 struct __type_traits<allocator<_Tp> > : _STLP_PRIV __alloc_type_traits<_Tp> {};
 421 #else
 422 _STLP_TEMPLATE_NULL
 423 struct __type_traits<allocator<char> > : _STLP_PRIV __alloc_type_traits<char> {};
 424 #  if defined (_STLP_HAS_WCHAR_T)
 425 _STLP_TEMPLATE_NULL
 426 struct __type_traits<allocator<wchar_t> > : _STLP_PRIV __alloc_type_traits<wchar_t> {};
 427 #  endif
 428 #  if defined (_STLP_USE_PTR_SPECIALIZATIONS)
 429 _STLP_TEMPLATE_NULL
 430 struct __type_traits<allocator<void*> > : _STLP_PRIV __alloc_type_traits<void*> {};
 431 #  endif
 432 #endif
 433
 434
 435 #if !defined (_STLP_FORCE_ALLOCATORS)
 436 #  define _STLP_FORCE_ALLOCATORS(a,y)
 437 #endif
 438
 439 #if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION) && !defined (_STLP_MEMBER_TEMPLATE_CLASSES)
 440 // The version for the default allocator, for rare occasion when we have partial spec w/o member template classes
 441 template <class _Tp, class _Tp1>
 442 struct _Alloc_traits<_Tp, allocator<_Tp1> > {
 443   typedef allocator<_Tp1> _Orig;
 444   typedef allocator<_Tp> allocator_type;
 445   static allocator_type create_allocator(const allocator<_Tp1 >& __a)
 446   { return allocator_type(_STLP_CONVERT_ALLOCATOR(__a, _Tp)); }
 447 };
 448 #endif
 449
 450 #if !defined (_STLP_DONT_SUPPORT_REBIND_MEMBER_TEMPLATE) && defined (_STLP_MEMBER_TEMPLATES)
 451 template <class _Tp, class _Alloc>
 452 inline _STLP_TYPENAME_ON_RETURN_TYPE _Alloc_traits<_Tp, _Alloc>::allocator_type  _STLP_CALL
 453 __stl_alloc_create(const _Alloc& __a, const _Tp*) {
 454   typedef typename _Alloc::_STLP_TEMPLATE rebind<_Tp>::other _Rebound_type;
 455   return _Rebound_type(__a);
 456 }
 457 #else
 458 // If custom allocators are being used without member template classes support :
 459 // user (on purpose) is forced to define rebind/get operations !!!
 460 template <class _Tp1, class _Tp2>
 461 inline allocator<_Tp2>& _STLP_CALL
 462 __stl_alloc_rebind(allocator<_Tp1>& __a, const _Tp2*) {  return (allocator<_Tp2>&)(__a); }
 463 template <class _Tp1, class _Tp2>
 464 inline allocator<_Tp2> _STLP_CALL
 465 __stl_alloc_create(const allocator<_Tp1>&, const _Tp2*) { return allocator<_Tp2>(); }
 466 #endif
 467
 468 _STLP_MOVE_TO_PRIV_NAMESPACE
 469
 470 // inheritance is being used for EBO optimization
 471 template <class _Value, class _Tp, class _MaybeReboundAlloc>
 472 class _STLP_alloc_proxy : public _MaybeReboundAlloc {
 473 private:
 474   typedef _MaybeReboundAlloc _Base;
 475   typedef typename _Base::size_type size_type;
 476   typedef _STLP_alloc_proxy<_Value, _Tp, _MaybeReboundAlloc> _Self;
 477 public:
 478   _Value _M_data;
 479
 480   _STLP_alloc_proxy (const _MaybeReboundAlloc& __a, _Value __p) :
 481     _MaybeReboundAlloc(__a), _M_data(__p) {}
 482
 483 #if !defined (_STLP_NO_MOVE_SEMANTIC)
 484   _STLP_alloc_proxy (__move_source<_Self> src) :
 485     _Base(_STLP_PRIV _AsMoveSource(src.get()._M_base())),
 486     _M_data(_STLP_PRIV _AsMoveSource(src.get()._M_data)) {}
 487
 488   _Base& _M_base()
 489   { return *this; }
 490 #endif
 491
 492 private:
 493   /* Following are helper methods to detect stateless allocators and avoid
 494    * swap in this case. For some compilers (VC6) it is a workaround for a
 495    * compiler bug in the Empty Base class Optimization feature, for others
 496    * it is a small optimization or nothing if no EBO. */
 497   void _M_swap_alloc(_Self&, const __true_type& /*_IsStateless*/)
 498   {}
 499
 500   void _M_swap_alloc(_Self& __x, const __false_type& /*_IsStateless*/) {
 501     _MaybeReboundAlloc &__base_this = *this;
 502     _MaybeReboundAlloc &__base_x = __x;
 503     _STLP_STD::swap(__base_this, __base_x);
 504   }
 505
 506 public:
 507   void _M_swap_alloc(_Self& __x) {
 508 #if !defined (__BORLANDC__)
 509     typedef typename _IsStateless<_MaybeReboundAlloc>::_Ret _StatelessAlloc;
 510 #else
 511     typedef typename __bool2type<_IsStateless<_MaybeReboundAlloc>::_Is>::_Ret _StatelessAlloc;
 512 #endif
 513     _M_swap_alloc(__x, _StatelessAlloc());
 514   }
 515
 516   /* We need to define the following swap implementation for allocator with state
 517    * as those allocators might have implement a special swap function to correctly
 518    * move datas from an instance to the oher, _STLP_alloc_proxy should not break
 519    * this mecanism. */
 520   void swap(_Self& __x) {
 521     _M_swap_alloc(__x);
 522     _STLP_STD::swap(_M_data, __x._M_data);
 523   }
 524
 525   _Tp* allocate(size_type __n, size_type& __allocated_n) {
 526 #if !defined (__BORLANDC__)
 527     typedef typename _IsSTLportClass<_MaybeReboundAlloc>::_Ret _STLportAlloc;
 528 #else
 529     typedef typename __bool2type<_IsSTLportClass<_MaybeReboundAlloc>::_Is>::_Ret _STLportAlloc;
 530 #endif
 531     return allocate(__n, __allocated_n, _STLportAlloc());
 532   }
 533
 534   // Unified interface to perform allocate()/deallocate() with limited
 535   // language support
 536 #if defined (_STLP_DONT_SUPPORT_REBIND_MEMBER_TEMPLATE)
 537   // else it is rebound already, and allocate() member is accessible
 538   _Tp* allocate(size_type __n)
 539   { return __stl_alloc_rebind(__STATIC_CAST(_Base&, *this), __STATIC_CAST(_Tp*, 0)).allocate(__n, 0); }
 540   void deallocate(_Tp* __p, size_type __n)
 541   { __stl_alloc_rebind(__STATIC_CAST(_Base&, *this), __STATIC_CAST(_Tp*, 0)).deallocate(__p, __n); }
 542 private:
 543   _Tp* allocate(size_type __n, size_type& __allocated_n, const __true_type& /*STLport allocator*/)
 544   { return __stl_alloc_rebind(__STATIC_CAST(_Base&, *this), __STATIC_CAST(_Tp*, 0))._M_allocate(__n, __allocated_n); }
 545 #else
 546   //Expose Standard allocate overload (using expression do not work for some compilers (Borland))
 547   _Tp* allocate(size_type __n)
 548   { return _Base::allocate(__n); }
 549 private:
 550   _Tp* allocate(size_type __n, size_type& __allocated_n, const __true_type& /*STLport allocator*/)
 551   { return _Base::_M_allocate(__n, __allocated_n); }
 552 #endif
 553
 554   _Tp* allocate(size_type __n, size_type& __allocated_n, const __false_type& /*STLport allocator*/)
 555   { __allocated_n = __n; return allocate(__n); }
 556 };
 557
 558 #if defined (_STLP_USE_TEMPLATE_EXPORT)
 559 _STLP_EXPORT_TEMPLATE_CLASS _STLP_alloc_proxy<char*, char, allocator<char> >;
 560 #  if defined (_STLP_HAS_WCHAR_T)
 561 _STLP_EXPORT_TEMPLATE_CLASS _STLP_alloc_proxy<wchar_t*, wchar_t, allocator<wchar_t> >;
 562 #  endif
 563 #  if defined (_STLP_USE_PTR_SPECIALIZATIONS)
 564 _STLP_EXPORT_TEMPLATE_CLASS _STLP_alloc_proxy<void**, void*, allocator<void*> >;
 565 #  endif
 566 #endif
 567
 568 _STLP_MOVE_TO_STD_NAMESPACE
 569 _STLP_END_NAMESPACE
 570
 571 #if defined (_STLP_EXPOSE_GLOBALS_IMPLEMENTATION) && !defined (_STLP_LINK_TIME_INSTANTIATION)
 572 #  include <stl/_alloc.c>
 573 #endif
 574
 575 #endif /* _STLP_INTERNAL_ALLOC_H */
 576
 577 // Local Variables:
 578 // mode:C++
 579 // End:
 580