Move STLPort to external/stlport.

Change-Id: I9cea43f9e1f98cefa654c5661dc7faa7f939068d

1 files changed, 0 insertions, 478 deletions

diff --git a/WebKit/android/stlport/stl/_hashtable.c b/WebKit/android/stlport/stl/_hashtable.c
deleted file mode 100644
index c9dafa2..0000000
--- a/WebKit/android/stlport/stl/_hashtable.c
+++ /dev/null
@@ -1,478 +0,0 @@
-/*
- * Copyright (c) 1994
- * Hewlett-Packard Company
- *
- * 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.
- *
- */
-#ifndef _STLP_HASHTABLE_C
-#define _STLP_HASHTABLE_C
-
-#ifndef _STLP_INTERNAL_HASHTABLE_H
-#  include <stl/_hashtable.h>
-#endif
-
-_STLP_BEGIN_NAMESPACE
-
-#if defined (_STLP_EXPOSE_GLOBALS_IMPLEMENTATION)
-
-_STLP_MOVE_TO_PRIV_NAMESPACE
-
-#  define __PRIME_LIST_BODY { \
-  7ul,          23ul, \
-  53ul,         97ul,         193ul,       389ul,       769ul,      \
-  1543ul,       3079ul,       6151ul,      12289ul,     24593ul,    \
-  49157ul,      98317ul,      196613ul,    393241ul,    786433ul,   \
-  1572869ul,    3145739ul,    6291469ul,   12582917ul,  25165843ul, \
-  50331653ul,   100663319ul,  201326611ul, 402653189ul, 805306457ul,\
-  1610612741ul, 3221225473ul, 4294967291ul  \
-}
-
-template <class _Dummy>
-size_t _STLP_CALL
-_Stl_prime<_Dummy>::_S_max_nb_buckets() {
-  const size_t _list[] = __PRIME_LIST_BODY;
-#  ifndef __MWERKS__
-  return _list[(sizeof(_list)/sizeof(_list[0])) - 1];
-#  else
-  return _list[30/sizeof(size_t) - 1]; // stupid MWERKS!
-#  endif
-}
-
-template <class _Dummy>
-size_t _STLP_CALL
-_Stl_prime<_Dummy>::_S_next_size(size_t __n) {
-  static const size_t _list[] = __PRIME_LIST_BODY;
-  const size_t* __first = _list;
-#  ifndef __MWERKS__
-  const size_t* __last =  _list + (sizeof(_list)/sizeof(_list[0]));
-#  else
-  const size_t* __last =  _list + (30/sizeof(size_t)); // stupid MWERKS
-#  endif
-  const size_t* pos = __lower_bound(__first, __last, __n, 
-                                    __less((size_t*)0), __less((size_t*)0), (ptrdiff_t*)0);
-  return (pos == __last ? *(__last - 1) : *pos);
-}
-
-#  undef __PRIME_LIST_BODY
-
-_STLP_MOVE_TO_STD_NAMESPACE
-
-#endif
-
-#if defined (_STLP_DEBUG)
-#  define hashtable _STLP_NON_DBG_NAME(hashtable)
-_STLP_MOVE_TO_PRIV_NAMESPACE
-#endif
-
-// fbp: these defines are for outline methods definitions.
-// needed to definitions to be portable. Should not be used in method bodies.
-
-#if defined ( _STLP_NESTED_TYPE_PARAM_BUG )
-#  define __size_type__       size_t
-#  define size_type           size_t
-#  define value_type          _Val
-#  define key_type            _Key
-#  define __reference__       _Val&
-
-#  define __iterator__        _Ht_iterator<_Val, _STLP_HEADER_TYPENAME _Traits::_NonConstTraits, \
-                                           _Key, _HF, _ExK, _EqK, _All>
-#  define __const_iterator__  _Ht_iterator<_Val, _STLP_HEADER_TYPENAME _Traits::_ConstTraits, \
-                                           _Key, _HF, _ExK, _EqK, _All>
-#else
-#  define __size_type__       _STLP_TYPENAME_ON_RETURN_TYPE hashtable<_Val, _Key, _HF, _Traits, _ExK, _EqK, _All>::size_type
-#  define __reference__       _STLP_TYPENAME_ON_RETURN_TYPE  hashtable<_Val, _Key, _HF, _Traits, _ExK, _EqK, _All>::reference
-#  define __iterator__        _STLP_TYPENAME_ON_RETURN_TYPE hashtable<_Val, _Key, _HF, _Traits, _ExK, _EqK, _All>::iterator
-#  define __const_iterator__  _STLP_TYPENAME_ON_RETURN_TYPE hashtable<_Val, _Key, _HF, _Traits, _ExK, _EqK, _All>::const_iterator
-#endif
-
-/*
- * This method is too difficult to implement for hashtable that do not
- * require a sorted operation on the stored type.
-template <class _Val, class _Key, class _HF,
-          class _Traits, class _ExK, class _EqK, class _All>
-bool hashtable<_Val,_Key,_HF,_Traits,_ExK,_EqK,_All>::_M_equal(
-              const hashtable<_Val,_Key,_HF,_Traits,_ExK,_EqK,_All>& __ht1,
-              const hashtable<_Val,_Key,_HF,_Traits,_ExK,_EqK,_All>& __ht2) {
-  return __ht1._M_buckets == __ht2._M_buckets &&
-         __ht1._M_elems == __ht2._M_elems;
-}
-*/
-
-/* Returns the iterator before the first iterator of the bucket __n and set
- * __n to the first previous bucket having the same first iterator as bucket
- * __n.
- */
-template <class _Val, class _Key, class _HF,
-          class _Traits, class _ExK, class _EqK, class _All>
-__iterator__
-hashtable<_Val,_Key,_HF,_Traits,_ExK,_EqK,_All>
-  ::_M_before_begin(size_type &__n) const {
-  return _S_before_begin(_M_elems, _M_buckets, __n);
-}
-
-template <class _Val, class _Key, class _HF,
-          class _Traits, class _ExK, class _EqK, class _All>
-__iterator__
-hashtable<_Val,_Key,_HF,_Traits,_ExK,_EqK,_All>
-  ::_S_before_begin(const _ElemsCont& __elems, const _BucketVector& __buckets,
-                    size_type &__n) {
-  _ElemsCont &__mutable_elems = __CONST_CAST(_ElemsCont&, __elems);
-  typename _BucketVector::const_iterator __bpos(__buckets.begin() + __n);
-
-  _ElemsIte __pos(*__bpos);
-  if (__pos == __mutable_elems.begin()) {
-    __n = 0;
-    return __mutable_elems.before_begin();
-  }
-
-  typename _BucketVector::const_iterator __bcur(__bpos);
-  _BucketType *__pos_node = __pos._M_node;
-  for (--__bcur; __pos_node == *__bcur; --__bcur);
-
-  __n = __bcur - __buckets.begin() + 1;
-  _ElemsIte __cur(*__bcur);
-  _ElemsIte __prev = __cur++;
-  for (; __cur != __pos; ++__prev, ++__cur);
-  return __prev;
-}
-
-
-template <class _Val, class _Key, class _HF,
-          class _Traits, class _ExK, class _EqK, class _All>
-__iterator__
-hashtable<_Val,_Key,_HF,_Traits,_ExK,_EqK,_All>
-  ::_M_insert_noresize(size_type __n, const value_type& __obj) {
-  //We always insert this element as 1st in the bucket to not break
-  //the elements order as equal elements must be kept next to each other.
-  size_type __prev = __n;
-  _ElemsIte __pos = _M_before_begin(__prev)._M_ite;
-
-  fill(_M_buckets.begin() + __prev, _M_buckets.begin() + __n + 1,
-       _M_elems.insert_after(__pos, __obj)._M_node);
-  ++_M_num_elements;
-  return iterator(_ElemsIte(_M_buckets[__n]));
-}
-
-template <class _Val, class _Key, class _HF,
-          class _Traits, class _ExK, class _EqK, class _All>
-pair<__iterator__, bool>
-hashtable<_Val,_Key,_HF,_Traits,_ExK,_EqK,_All>
-  ::insert_unique_noresize(const value_type& __obj) {
-  const size_type __n = _M_bkt_num(__obj);
-  _ElemsIte __cur(_M_buckets[__n]);
-  _ElemsIte __last(_M_buckets[__n + 1]);
-
-  if (__cur != __last) {
-    for (; __cur != __last; ++__cur) {
-      if (_M_equals(_M_get_key(*__cur), _M_get_key(__obj))) {
-        //We check that equivalent keys have equals hash code as otherwise, on resize,
-        //equivalent value might not be in the same bucket
-        _STLP_ASSERT(_M_hash(_M_get_key(*__cur)) == _M_hash(_M_get_key(__obj)))
-        return pair<iterator, bool>(iterator(__cur), false);
-      }
-    }
-    /* Here we do not rely on the _M_insert_noresize method as we know
-     * that we cannot break element orders, elements are unique, and
-     * insertion after the first bucket element is faster than what is
-     * done in _M_insert_noresize.
-     */
-    __cur = _M_elems.insert_after(_ElemsIte(_M_buckets[__n]), __obj);
-    ++_M_num_elements;
-    return pair<iterator, bool>(iterator(__cur), true);
-  }
-
-  return pair<iterator, bool>(_M_insert_noresize(__n, __obj), true);
-}
-
-template <class _Val, class _Key, class _HF,
-          class _Traits, class _ExK, class _EqK, class _All>
-__iterator__
-hashtable<_Val,_Key,_HF,_Traits,_ExK,_EqK,_All>
-  ::insert_equal_noresize(const value_type& __obj) {
-  const size_type __n = _M_bkt_num(__obj);
-  {
-    _ElemsIte __cur(_M_buckets[__n]);
-    _ElemsIte __last(_M_buckets[__n + 1]);
-
-    for (; __cur != __last; ++__cur) {
-      if (_M_equals(_M_get_key(*__cur), _M_get_key(__obj))) {
-        //We check that equivalent keys have equals hash code as otherwise, on resize,
-        //equivalent value might not be in the same bucket
-        _STLP_ASSERT(_M_hash(_M_get_key(*__cur)) == _M_hash(_M_get_key(__obj)))
-        ++_M_num_elements;
-        return _M_elems.insert_after(__cur, __obj);
-      }
-    }
-  }
-
-  return _M_insert_noresize(__n, __obj);
-}
-
-template <class _Val, class _Key, class _HF,
-          class _Traits, class _ExK, class _EqK, class _All>
-__reference__
-hashtable<_Val,_Key,_HF,_Traits,_ExK,_EqK,_All>
-  ::_M_insert(const value_type& __obj) {
-  resize(_M_num_elements + 1);
-  return *insert_unique_noresize(__obj).first;
-}
-
-/*
-template <class _Val, class _Key, class _HF,
-          class _Traits, class _ExK, class _EqK, class _All>
-__reference__
-hashtable<_Val,_Key,_HF,_Traits,_ExK,_EqK,_All>
-  ::find_or_insert(const value_type& __obj) {
-  _Node* __first = _M_find(_M_get_key(__obj));
-  if (__first)
-    return __first->_M_val;
-  else
-    return _M_insert(__obj);
-}
-*/
-
-template <class _Val, class _Key, class _HF,
-          class _Traits, class _ExK, class _EqK, class _All>
-__size_type__
-hashtable<_Val,_Key,_HF,_Traits,_ExK,_EqK,_All>
-  ::erase(const key_type& __key) {
-  const size_type __n = _M_bkt_num_key(__key);
-
-  _ElemsIte __cur(_M_buckets[__n]);
-  _ElemsIte __last(_M_buckets[__n + 1]);
-  if (__cur == __last)
-    return 0;
-
-  size_type __erased = 0;
-  if (_M_equals(_M_get_key(*__cur), __key)) {
-    //We look for the pos before __cur:
-    size_type __prev_b = __n;
-    _ElemsIte __prev = _M_before_begin(__prev_b)._M_ite;
-    do {
-      __cur = _M_elems.erase_after(__prev);
-      ++__erased;
-    } while ((__cur != __last) && _M_equals(_M_get_key(*__cur), __key));
-    fill(_M_buckets.begin() + __prev_b, _M_buckets.begin() + __n + 1, __cur._M_node);
-  }
-  else {
-    _ElemsIte __prev = __cur++;
-    for (; __cur != __last; ++__prev, ++__cur) {
-      if (_M_equals(_M_get_key(*__cur), __key)) {
-        do {
-          __cur = _M_elems.erase_after(__prev);
-          ++__erased;
-        } while ((__cur != __last) && _M_equals(_M_get_key(*__cur), __key));
-        break;
-      }
-    }
-  }
-
-  _M_num_elements -= __erased;
-  return __erased;
-}
-
-template <class _Val, class _Key, class _HF,
-          class _Traits, class _ExK, class _EqK, class _All>
-void hashtable<_Val,_Key,_HF,_Traits,_ExK,_EqK,_All>
-  ::erase(const_iterator __it) {
-  const size_type __n = _M_bkt_num(*__it);
-  _ElemsIte __cur(_M_buckets[__n]);
-
-  if (__cur == __it._M_ite) {
-    size_type __prev_b = __n;
-    _ElemsIte __prev = _M_before_begin(__prev_b)._M_ite;
-    fill(_M_buckets.begin() + __prev_b, _M_buckets.begin() + __n + 1,
-         _M_elems.erase_after(__prev)._M_node);
-    --_M_num_elements;
-  }
-  else {
-    _ElemsIte __prev = __cur++;
-    _ElemsIte __last(_M_buckets[__n + 1]);
-    for (; __cur != __last; ++__prev, ++__cur) {
-      if (__cur == __it._M_ite) {
-        _M_elems.erase_after(__prev);
-        --_M_num_elements;
-        break;
-      }
-    }
-  }
-}
-
-template <class _Val, class _Key, class _HF,
-          class _Traits, class _ExK, class _EqK, class _All>
-void hashtable<_Val,_Key,_HF,_Traits,_ExK,_EqK,_All>
-  ::erase(const_iterator __first, const_iterator __last) {
-  if (__first == __last)
-    return;
-  size_type __f_bucket = _M_bkt_num(*__first);
-  size_type __l_bucket = __last != end() ? _M_bkt_num(*__last) : (_M_buckets.size() - 1);
-
-  _ElemsIte __cur(_M_buckets[__f_bucket]);
-  _ElemsIte __prev;
-  if (__cur == __first._M_ite) {
-    __prev = _M_before_begin(__f_bucket)._M_ite;
-  }
-  else {
-    _ElemsIte __last(_M_buckets[++__f_bucket]);
-    __prev = __cur++;
-    for (; (__cur != __last) && (__cur != __first._M_ite); ++__prev, ++__cur);
-  }
-  //We do not use the slist::erase_after method taking a range to count the
-  //number of erased elements:
-  while (__cur != __last._M_ite) {
-    __cur = _M_elems.erase_after(__prev);
-    --_M_num_elements;
-  }
-  fill(_M_buckets.begin() + __f_bucket, _M_buckets.begin() + __l_bucket + 1, __cur._M_node);
-}
-
-template <class _Val, class _Key, class _HF,
-          class _Traits, class _ExK, class _EqK, class _All>
-void hashtable<_Val,_Key,_HF,_Traits,_ExK,_EqK,_All>
-  ::rehash(size_type __num_buckets_hint) {
-  if ((bucket_count() >= __num_buckets_hint) &&
-      (max_load_factor() > load_factor()))
-    return;
-
-  //Here if max_load_factor is lower than 1.0 the resulting value might not be representable
-  //as a size_type. The result concerning the respect of the max_load_factor will then be
-  //undefined.
-  __num_buckets_hint = (max) (__num_buckets_hint, (size_type)((float)size() / max_load_factor()));
-  size_type __num_buckets = _STLP_PRIV _Stl_prime_type::_S_next_size(__num_buckets_hint);
-  _M_rehash(__num_buckets);
-}
-
-template <class _Val, class _Key, class _HF,
-          class _Traits, class _ExK, class _EqK, class _All>
-void hashtable<_Val,_Key,_HF,_Traits,_ExK,_EqK,_All>
-  ::resize(size_type __num_elements_hint) {
-  if (((float)__num_elements_hint / (float)bucket_count() <= max_load_factor()) &&
-      (max_load_factor() >= load_factor())) {
-    return;
-  }
-
-  size_type __num_buckets_hint = (size_type)((float)(max) (__num_elements_hint, size()) / max_load_factor());
-  size_type __num_buckets = _STLP_PRIV _Stl_prime_type::_S_next_size(__num_buckets_hint);
-#if defined (_STLP_DEBUG)
-  _M_check();
-#endif
-  _M_rehash(__num_buckets);
-}
-
-template <class _Val, class _Key, class _HF,
-          class _Traits, class _ExK, class _EqK, class _All>
-void hashtable<_Val,_Key,_HF,_Traits,_ExK,_EqK,_All>
-  ::_M_rehash(size_type __num_buckets) {
-  _ElemsCont __tmp_elems(_M_elems.get_allocator());
-  _BucketVector __tmp(__num_buckets + 1, __STATIC_CAST(_BucketType*, 0), _M_buckets.get_allocator());
-  _ElemsIte __cur, __last(_M_elems.end());
-  while (!_M_elems.empty()) {
-    __cur = _M_elems.begin();
-    size_type __new_bucket = _M_bkt_num(*__cur, __num_buckets);
-    _ElemsIte __ite(__cur), __before_ite(__cur);
-    for (++__ite;
-         __ite != __last && _M_equals(_M_get_key(*__cur), _M_get_key(*__ite));
-         ++__ite, ++__before_ite);
-    size_type __prev_bucket = __new_bucket;
-    _ElemsIte  __prev = _S_before_begin(__tmp_elems, __tmp, __prev_bucket)._M_ite;
-    __tmp_elems.splice_after(__prev, _M_elems, _M_elems.before_begin(), __before_ite);
-    fill(__tmp.begin() + __prev_bucket, __tmp.begin() + __new_bucket + 1, __cur._M_node);
-  }
-  _M_elems.swap(__tmp_elems);
-  _M_buckets.swap(__tmp);
-}
-
-#if defined (_STLP_DEBUG)
-template <class _Val, class _Key, class _HF,
-          class _Traits, class _ExK, class _EqK, class _All>
-void hashtable<_Val,_Key,_HF,_Traits,_ExK,_EqK,_All>::_M_check() const {
-  //We check that hash code of stored keys haven't change and also that equivalent
-  //relation hasn't been modified
-  size_t __num_buckets = bucket_count();
-  for (size_t __b = 0; __b < __num_buckets; ++__b) {
-    _ElemsIte __cur(_M_buckets[__b]), __last(_M_buckets[__b + 1]);
-    _ElemsIte __fst(__cur), __snd(__cur);
-    for (; __cur != __last; ++__cur) {
-      _STLP_ASSERT( _M_bkt_num(*__cur, __num_buckets) == __b )
-      _STLP_ASSERT( !_M_equals(_M_get_key(*__fst), _M_get_key(*__cur)) || _M_equals(_M_get_key(*__snd), _M_get_key(*__cur)) )
-      if (__fst != __snd)
-        ++__fst;
-      if (__snd != __cur)
-        ++__snd;
-    }
-  }
-}
-#endif
-
-template <class _Val, class _Key, class _HF,
-          class _Traits, class _ExK, class _EqK, class _All>
-void hashtable<_Val,_Key,_HF,_Traits,_ExK,_EqK,_All>::clear() {
-  _M_elems.clear();
-  _M_buckets.assign(_M_buckets.size(), __STATIC_CAST(_BucketType*, 0));
-  _M_num_elements = 0;
-}
-
-template <class _Val, class _Key, class _HF,
-          class _Traits, class _ExK, class _EqK, class _All>
-void hashtable<_Val,_Key,_HF,_Traits,_ExK,_EqK,_All>
-  ::_M_copy_from(const hashtable<_Val,_Key,_HF,_Traits,_ExK,_EqK,_All>& __ht) {
-  _M_elems.clear();
-  _M_elems.insert(_M_elems.end(), __ht._M_elems.begin(), __ht._M_elems.end());
-  _M_buckets.resize(__ht._M_buckets.size());
-  _ElemsConstIte __src(__ht._M_elems.begin()), __src_end(__ht._M_elems.end());
-  _ElemsIte __dst(_M_elems.begin());
-  typename _BucketVector::const_iterator __src_b(__ht._M_buckets.begin()),
-                                         __src_end_b(__ht._M_buckets.end());
-  typename _BucketVector::iterator __dst_b(_M_buckets.begin()), __dst_end_b(_M_buckets.end());
-  for (; __src != __src_end; ++__src, ++__dst) {
-    for (; __src_b != __src_end_b; ++__src_b, ++__dst_b) {
-      if (*__src_b == __src._M_node) {
-        *__dst_b = __dst._M_node;
-      }
-      else
-        break;
-    }
-  }
-  fill(__dst_b, __dst_end_b, __STATIC_CAST(_BucketType*, 0));
-  _M_num_elements = __ht._M_num_elements;
-  _M_max_load_factor = __ht._M_max_load_factor;
-}
-
-#undef __iterator__
-#undef const_iterator
-#undef __size_type__
-#undef __reference__
-#undef size_type
-#undef value_type
-#undef key_type
-#undef __stl_num_primes
-
-#if defined (_STLP_DEBUG)
-#  undef hashtable
-_STLP_MOVE_TO_STD_NAMESPACE
-#endif
-
-_STLP_END_NAMESPACE
-
-#endif /*  _STLP_HASHTABLE_C */
-
-// Local Variables:
-// mode:C++
-// End: