X-Git-Url: http://git.buserror.net/cgi-bin/gitweb.cgi?p=polintos%2Fscott%2Fpriv.git;a=blobdiff_plain;f=include%2Fc%2B%2B%2Fstl%2Fstl%2F_vector.c;fp=include%2Fc%2B%2B%2Fstl%2Fstl%2F_vector.c;h=c46a23ebbf96d234a2f1e931c4a4ce11251fa21f;hp=0000000000000000000000000000000000000000;hb=173d8903eb9d51a4ea7d7fa3e52dc86c9bb6d4f1;hpb=b024710fe2b60cd4a42a8993b61333d6cdb56ca3 diff --git a/include/c++/stl/stl/_vector.c b/include/c++/stl/stl/_vector.c new file mode 100644 index 0000000..c46a23e --- /dev/null +++ b/include/c++/stl/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 +#endif + +#include + +_STLP_BEGIN_NAMESPACE + +_STLP_MOVE_TO_PRIV_NAMESPACE + +template +void _Vector_base<_Tp,_Alloc>::_M_throw_length_error() const { + __stl_throw_length_error("vector"); +} + +template +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 +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 +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 +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 +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 +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 +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 +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 +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 +__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: