Use STLPort instead of our stripped version. DO NOT MERGE.

This fixes the simulator build and allows us to get closer to sharing code with
chromium.

STLPort was copied with minor edits from the Android port of gears.

1 files changed, 675 insertions, 0 deletions

diff --git a/WebKit/android/stlport/stl/_alloc.h b/WebKit/android/stlport/stl/_alloc.h
new file mode 100644
index 0000000..48a875d
--- /dev/null
+++ b/WebKit/android/stlport/stl/_alloc.h
@@ -0,0 +1,675 @@
+/*
+ *
+ * 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
+
+#if !defined (_STLP_DEBUG_H) && (defined(_STLP_DEBUG) || defined(_STLP_ASSERTIONS) || defined(_STLP_DEBUG_ALLOC))
+#  include <stl/debug/_debug.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 __THROW_BAD_ALLOC
+#  if !defined(_STLP_USE_EXCEPTIONS)
+#    ifndef _STLP_INTERNAL_CSTDIO
+#      include <stl/_cstdio.h>
+#    endif
+#    define __THROW_BAD_ALLOC puts("out of memory\n"); exit(1)
+#  else
+#    define __THROW_BAD_ALLOC throw _STLP_STD::bad_alloc()
+#  endif
+#endif
+
+#ifndef _STLP_INTERNAL_NEW_HEADER
+#  include <stl/_new.h>
+#endif
+
+#ifndef _STLP_INTERNAL_CONSTRUCT_H
+#  include <stl/_construct.h>
+#endif
+
+#if !defined (__ALLOC)
+#  define __ALLOC __sgi_alloc
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+#if defined (_STLP_USE_RAW_SGI_ALLOCATORS)
+template <class _Tp, class _Alloc> struct __allocator;
+#endif
+
+// 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;
+#if defined (_STLP_MEMBER_TEMPLATE_CLASSES) && defined (_STLP_USE_RAW_SGI_ALLOCATORS)
+  template <class _Tp1> struct rebind {
+    typedef __allocator<_Tp1, __malloc_alloc> other;
+  };
+#endif
+  static void* _STLP_CALL allocate(size_t& __n)
+#if !defined (_STLP_USE_NO_IOSTREAMS)
+  ;
+#else
+  {
+    void *__result = malloc(__n);
+#  if defined (_STLP_MALLOC_USABLE_SIZE)
+    if (__result != 0) {
+      __n = _STLP_MALLOC_USABLE_SIZE(__result);
+    }
+#  endif
+    if (__result == 0) {
+      __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;
+#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__) || defined (_WIN64)
+enum {_ALIGN = 16, _ALIGN_SHIFT = 4, _MAX_BYTES = 256};
+#  else
+enum {_ALIGN = 8, _ALIGN_SHIFT = 3, _MAX_BYTES = 128};
+#  endif /* __OS400__ */
+
+#if !defined (_STLP_USE_NO_IOSTREAMS)
+
+#  if !defined (_STLP_USE_SIMPLE_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.
+// Define _STLP_USE_SIMPLE_NODE_ALLOC to use __new_alloc instead, which
+// can be implemented without out-of-line functions.
+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;
+#  if defined (_STLP_MEMBER_TEMPLATE_CLASSES) && defined (_STLP_USE_RAW_SGI_ALLOCATORS)
+  template <class _Tp1> struct rebind {
+    typedef __allocator<_Tp1, __node_alloc> 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 __debug_alloc<__node_alloc>;
+#    endif
+
+#  else /* _STLP_USE_SIMPLE_NODE_ALLOC */
+// Use __new_alloc instead of __node_alloc. This prevents the need for
+// out-of-line _M_allocate and _M_dealloacte functions.
+typedef __new_alloc __node_alloc;
+
+#  endif /* _STLP_USE_SIMPLE_NODE_ALLOC */
+
+#endif /* _STLP_USE_NO_IOSTREAMS */
+
+#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 /* _STLP_MEMBER_TEMPLATES || !_STLP_CLASS_PARTIAL_SPECIALIZATION */
+
+// 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 /* !_STLP_DONT_SUPPORT_REBIND_MEMBER_TEMPLATE */
+};
+
+#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 /* _STLP_USE_PERTHREAD_ALLOC */
+
+#  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> __sgi_alloc;
+#    else
+typedef __malloc_alloc __sgi_alloc;
+#    endif /* _STLP_DEBUG_ALLOC */
+
+typedef __malloc_alloc __single_client_alloc;
+typedef __malloc_alloc __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 __single_client_alloc;
+typedef __node_alloc __multithreaded_alloc;
+
+#  endif /* _STLP_USE_NEWALLOC */
+#endif /* _STLP_USE_PERTHREAD_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>
+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 {}
+  allocator(__move_source<allocator<_Tp> > src) _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) {
+    if (__n > max_size()) {
+      __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)
+      if (__ret != 0) {
+        memset((char*)__ret, _STLP_SHRED_BYTE, __buf_size);
+      }
+#endif
+      return __ret;
+    }
+    else
+      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));
+    }
+  }
+  // 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_reference __val) { _STLP_STD::_Copy_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
+
+#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND) && !defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER)
+  //This is just to make swap workaround for compiler without template function partial
+  //happy.
+  void swap(allocator<_Tp>&) {}
+#endif
+
+#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* allocate(size_type __n, size_type& __allocated_n) {
+    if (__n > max_size()) {
+      __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)
+      if (__ret != 0) {
+        memset((char*)__ret, _STLP_SHRED_BYTE, __buf_size);
+      }
+#endif
+      __allocated_n = __buf_size / sizeof(value_type);
+      return __ret;
+    }
+    else
+      return 0;
+  }
+};
+
+_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
+#  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 /* _STLP_CLASS_PARTIAL_SPECIALIZATION */
+
+#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_DONT_SUPPORT_REBIND_MEMBER_TEMPLATE */
+
+#if defined (_STLP_USE_RAW_SGI_ALLOCATORS)
+// move obsolete stuff out of the way
+#  include <stl/_alloc_old.h>
+#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) {}
+
+  _STLP_alloc_proxy (__move_source<_Self> src) :
+    _MaybeReboundAlloc(_STLP_PRIV _AsMoveSource<_Base>(src.get())),
+    _M_data(_STLP_PRIV _AsMoveSource<_Value>(src.get()._M_data)) {}
+
+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)).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::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: