Use STLPort instead of our stripped version.

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, 235 insertions, 0 deletions

diff --git a/WebKit/android/stlport/stl/_vector.c b/WebKit/android/stlport/stl/_vector.c
new file mode 100644
index 0000000..c46a23e
--- /dev/null
+++ b/WebKit/android/stlport/stl/_vector.c
@@ -0,0 +1,235 @@
+/*
+ *
+ *
+ * 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_VECTOR_C
+#define _STLP_VECTOR_C
+
+#if !defined (_STLP_INTERNAL_VECTOR_H)
+#  include <stl/_vector.h>
+#endif
+
+#include <stl/_range_errors.h>
+
+_STLP_BEGIN_NAMESPACE
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template <class _Tp, class _Alloc>
+void _Vector_base<_Tp,_Alloc>::_M_throw_length_error() const {
+  __stl_throw_length_error("vector");
+}
+
+template <class _Tp, class _Alloc>
+void _Vector_base<_Tp, _Alloc>::_M_throw_out_of_range() const {
+  __stl_throw_out_of_range("vector");
+}
+
+#if defined (_STLP_USE_PTR_SPECIALIZATIONS)
+#  define vector _STLP_PTR_IMPL_NAME(vector)
+#elif defined (_STLP_DEBUG)
+#  define vector _STLP_NON_DBG_NAME(vector)
+#else
+_STLP_MOVE_TO_STD_NAMESPACE
+#endif
+
+#if defined (_STLP_NESTED_TYPE_PARAM_BUG)
+#  define __iterator__  _Tp*
+#else
+#  define __iterator__  _STLP_TYPENAME_ON_RETURN_TYPE vector<_Tp, _Alloc>::iterator
+#endif
+
+template <class _Tp, class _Alloc>
+void vector<_Tp, _Alloc>::reserve(size_type __n) {
+  if (capacity() < __n) {
+    if (max_size() < __n) {
+      this->_M_throw_length_error();
+    }
+
+    const size_type __old_size = size();
+    pointer __tmp;
+    if (this->_M_start) {
+      __tmp = _M_allocate_and_copy(__n, this->_M_start, this->_M_finish);
+      _M_clear();
+    } else {
+      __tmp = this->_M_end_of_storage.allocate(__n, __n);
+    }
+    _M_set(__tmp, __tmp + __old_size, __tmp + __n);
+  }
+}
+
+template <class _Tp, class _Alloc>
+void vector<_Tp, _Alloc>::_M_insert_overflow_aux(pointer __pos, const _Tp& __x, const __false_type& /*DO NOT USE!!*/,
+                                                 size_type __fill_len, bool __atend ) {
+  const size_type __old_size = size();
+  size_type __len = __old_size + (max)(__old_size, __fill_len);
+
+  pointer __new_start = this->_M_end_of_storage.allocate(__len, __len);
+  pointer __new_finish = __new_start;
+  _STLP_TRY {
+    __new_finish = _STLP_PRIV __uninitialized_move(this->_M_start, __pos, __new_start, _TrivialUCopy(), _Movable());
+    // handle insertion
+    if (__fill_len == 1) {
+      _Copy_Construct(__new_finish, __x);
+      ++__new_finish;
+    } else
+      __new_finish = _STLP_PRIV __uninitialized_fill_n(__new_finish, __fill_len, __x);
+    if (!__atend)
+      __new_finish = _STLP_PRIV __uninitialized_move(__pos, this->_M_finish, __new_finish, _TrivialUCopy(), _Movable()); // copy remainder
+  }
+  _STLP_UNWIND((_STLP_STD::_Destroy_Range(__new_start,__new_finish),
+               this->_M_end_of_storage.deallocate(__new_start,__len)))
+  _M_clear_after_move();
+  _M_set(__new_start, __new_finish, __new_start + __len);
+}
+
+template <class _Tp, class _Alloc>
+void vector<_Tp, _Alloc>::_M_insert_overflow(pointer __pos, const _Tp& __x, const __true_type& /*_TrivialCopy*/,
+                                             size_type __fill_len, bool __atend ) {
+  const size_type __old_size = size();
+  size_type __len = __old_size + (max)(__old_size, __fill_len);
+
+  pointer __new_start = this->_M_end_of_storage.allocate(__len, __len);
+  pointer __new_finish = __STATIC_CAST(pointer, _STLP_PRIV __copy_trivial(this->_M_start, __pos, __new_start));
+  // handle insertion
+  __new_finish = _STLP_PRIV __fill_n(__new_finish, __fill_len, __x);
+  if (!__atend)
+    __new_finish = __STATIC_CAST(pointer, _STLP_PRIV __copy_trivial(__pos, this->_M_finish, __new_finish)); // copy remainder
+  _M_clear();
+  _M_set(__new_start, __new_finish, __new_start + __len);
+}
+
+template <class _Tp, class _Alloc>
+void vector<_Tp, _Alloc>::_M_fill_insert_aux(iterator __pos, size_type __n,
+                                             const _Tp& __x, const __true_type& /*_Movable*/) {
+  if (_M_is_inside(__x)) {
+    _Tp __x_copy = __x;
+    _M_fill_insert_aux(__pos, __n, __x_copy, __true_type());
+    return;
+  }
+  iterator __src = this->_M_finish - 1;
+  iterator __dst = __src + __n;
+  for (; __src >= __pos; --__dst, --__src) {
+    _STLP_STD::_Move_Construct(__dst, *__src);
+    _STLP_STD::_Destroy_Moved(__src);
+  }
+  _STLP_PRIV __uninitialized_fill_n(__pos, __n, __x);
+  this->_M_finish += __n;
+}
+
+template <class _Tp, class _Alloc>
+void vector<_Tp, _Alloc>::_M_fill_insert_aux (iterator __pos, size_type __n,
+                                              const _Tp& __x, const __false_type& /*_Movable*/) {
+  //Here self referencing needs to be checked even for non movable types.
+  if (_M_is_inside(__x)) {
+    _Tp __x_copy = __x;
+    _M_fill_insert_aux(__pos, __n, __x_copy, __false_type());
+    return;
+  }
+  const size_type __elems_after = this->_M_finish - __pos;
+  pointer __old_finish = this->_M_finish;
+  if (__elems_after > __n) {
+    _STLP_PRIV __ucopy_ptrs(this->_M_finish - __n, this->_M_finish, this->_M_finish, _TrivialUCopy());
+    this->_M_finish += __n;
+    _STLP_PRIV __copy_backward_ptrs(__pos, __old_finish - __n, __old_finish, _TrivialCopy());
+    _STLP_STD::fill(__pos, __pos + __n, __x);
+  } else {
+    this->_M_finish = _STLP_PRIV __uninitialized_fill_n(this->_M_finish, __n - __elems_after, __x);
+    _STLP_PRIV __ucopy_ptrs(__pos, __old_finish, this->_M_finish, _TrivialUCopy());
+    this->_M_finish += __elems_after;
+    _STLP_STD::fill(__pos, __old_finish, __x);
+  }
+}
+
+template <class _Tp, class _Alloc>
+void vector<_Tp, _Alloc>::_M_fill_insert(iterator __pos,
+                                         size_type __n, const _Tp& __x) {
+  if (__n != 0) {
+    if (size_type(this->_M_end_of_storage._M_data - this->_M_finish) >= __n) {
+      _M_fill_insert_aux(__pos, __n, __x, _Movable());
+    } else
+      _M_insert_overflow(__pos, __x, _TrivialCopy(), __n);
+  }
+}
+
+template <class _Tp, class _Alloc>
+vector<_Tp, _Alloc>& vector<_Tp, _Alloc>::operator = (const vector<_Tp, _Alloc>& __x) {
+  if (&__x != this) {
+    const size_type __xlen = __x.size();
+    if (__xlen > capacity()) {
+      size_type __len = __xlen;
+      pointer __tmp = _M_allocate_and_copy(__len, __CONST_CAST(const_pointer, __x._M_start) + 0,
+                                                  __CONST_CAST(const_pointer, __x._M_finish) + 0);
+      _M_clear();
+      this->_M_start = __tmp;
+      this->_M_end_of_storage._M_data = this->_M_start + __len;
+    } else if (size() >= __xlen) {
+      pointer __i = _STLP_PRIV __copy_ptrs(__CONST_CAST(const_pointer, __x._M_start) + 0,
+                                           __CONST_CAST(const_pointer, __x._M_finish) + 0, this->_M_start, _TrivialCopy());
+      _STLP_STD::_Destroy_Range(__i, this->_M_finish);
+    } else {
+      _STLP_PRIV __copy_ptrs(__CONST_CAST(const_pointer, __x._M_start),
+                             __CONST_CAST(const_pointer, __x._M_start) + size(), this->_M_start, _TrivialCopy());
+      _STLP_PRIV __ucopy_ptrs(__CONST_CAST(const_pointer, __x._M_start) + size(),
+                              __CONST_CAST(const_pointer, __x._M_finish) + 0, this->_M_finish, _TrivialUCopy());
+    }
+    this->_M_finish = this->_M_start + __xlen;
+  }
+  return *this;
+}
+
+template <class _Tp, class _Alloc>
+void vector<_Tp, _Alloc>::_M_fill_assign(size_t __n, const _Tp& __val) {
+  if (__n > capacity()) {
+    vector<_Tp, _Alloc> __tmp(__n, __val, get_allocator());
+    __tmp.swap(*this);
+  } else if (__n > size()) {
+    fill(begin(), end(), __val);
+    this->_M_finish = _STLP_PRIV __uninitialized_fill_n(this->_M_finish, __n - size(), __val);
+  } else
+    erase(_STLP_PRIV __fill_n(begin(), __n, __val), end());
+}
+
+template <class _Tp, class _Alloc>
+__iterator__
+vector<_Tp, _Alloc>::insert(iterator __pos, const _Tp& __x) {
+  size_type __n = __pos - begin();
+  _M_fill_insert(__pos, 1, __x);
+  return begin() + __n;
+}
+
+#undef __iterator__
+
+#if defined (vector)
+#  undef vector
+_STLP_MOVE_TO_STD_NAMESPACE
+#endif
+
+_STLP_END_NAMESPACE
+
+#endif /*  _STLP_VECTOR_C */
+
+// Local Variables:
+// mode:C++
+// End: