From: John Hodge Date: Fri, 23 May 2014 00:12:43 +0000 (+0800) Subject: Usermode/libc++ - ::std::list allocator and insert, header X-Git-Url: https://git.ucc.asn.au/?a=commitdiff_plain;h=c55ececc6533d5e1e72adea971219bf701960336;p=tpg%2Facess2.git Usermode/libc++ - ::std::list allocator and insert, header --- diff --git a/Usermode/Libraries/libc++.so_src/include_exp/allocator b/Usermode/Libraries/libc++.so_src/include_exp/allocator index 943dc0f6..656507f6 100644 --- a/Usermode/Libraries/libc++.so_src/include_exp/allocator +++ b/Usermode/Libraries/libc++.so_src/include_exp/allocator @@ -8,6 +8,7 @@ #ifndef _LIBCXX_ALLOCATOR_ #define _LIBCXX_ALLOCATOR_ +#include "new" #include "cstddef" namespace std { @@ -57,7 +58,7 @@ public: return ((size_type)-1) / sizeof(value_type); } void construct( pointer p, const_reference val ) { - ::new ((void*)p) value_type (val); + new ((void*)p) value_type (val); } // C++11 //template diff --git a/Usermode/Libraries/libc++.so_src/include_exp/list b/Usermode/Libraries/libc++.so_src/include_exp/list index 602d2ae4..060e4e31 100644 --- a/Usermode/Libraries/libc++.so_src/include_exp/list +++ b/Usermode/Libraries/libc++.so_src/include_exp/list @@ -9,34 +9,53 @@ #define _LIBCXX_LIST_ #include +#include "allocator" namespace std { namespace _bits { -template class list_iterator; +template class list_iterator; template class list_item; } -template +template > class list { - friend class ::std::_bits::list_iterator; - typedef ::std::_bits::list_item item_type; + typedef ::std::_bits::list_item const_item_type; + friend class ::std::_bits::list_iterator; + + typedef typename Alloc::template rebind::other item_allocator; +public: + typedef T value_type; + typedef Alloc allocator_type; + typedef typename allocator_type::reference reference; + typedef typename allocator_type::const_reference const_reference; + typedef typename allocator_type::pointer pointer; + typedef typename allocator_type::const_pointer const_pointer; + typedef _bits::list_iterator iterator; + typedef _bits::list_iterator const_iterator; + typedef int difference_type; + typedef size_t size_type; + +private: + item_allocator m_item_allocator; + allocator_type m_allocator; item_type *m_start; item_type *m_end; + public: - typedef T value_type; - typedef value_type& reference; - typedef const value_type& const_reference; - typedef _bits::list_iterator iterator; - typedef _bits::list_iterator const_iterator; - - list(): + list(const allocator_type& alloc = allocator_type()): + m_item_allocator(), + m_allocator(alloc), m_start(0), m_end(0) { } - list(size_t n, const value_type& val = value_type()); + list(size_t n, const value_type& val = value_type(), const allocator_type& alloc = allocator_type()): + list() + { + assign(n, val); + } list(const list& x); ~list() { clear(); @@ -69,6 +88,78 @@ public: T& back(); const T& back() const; + void assign(size_type n, const value_type& val) { + clear(); + for( size_t i = 0; i < n; i ++ ) + { + push_back(val); + } + } + + void push_front(const value_type& val) { + insert(front(), val); + } + void pop_front() { + erase(front()); + } + void push_back(const value_type& val) { + insert(end(), val); + } + void pop_back() { + erase(end()); + } + + iterator insert(iterator position, const value_type& val) { + item_type *newi = m_item_allocator.allocate(1); + m_allocator.construct(&newi->value, val); + if( position == end() ) { + newi->next = 0; + newi->prev = m_end; + m_end->next = newi; + m_end = newi; + } + else if( position == begin() ) { + newi->next = m_start; + newi->prev = 0; + m_start->prev = newi; + m_start = newi; + } + else { + newi->prev = position.cur->prev; + newi->next = position.cur; + position.cur->prev->next = newi; + position.cur->prev = newi; + } + return ++position; + } + void insert(iterator position, size_type n, const value_type& val) { + for( size_type i = 0; i < n; i ++ ) + { + position = insert(position, val); + } + } + iterator erase(iterator position) { + if( position == end() ) { + } + else { + item_type *oldi = position.cur; + position ++; + + if(oldi->prev) + oldi->prev->next = oldi->next; + else + m_start = oldi->next; + if(oldi->next) + oldi->next->prev = oldi->prev; + else + m_end = oldi->prev; + + m_allocator.destroy(&oldi->value); + m_item_allocator.deallocate(oldi, 1); + } + return position; + } + void clear() { while( m_start ) { item_type* item = m_start; @@ -84,18 +175,18 @@ namespace _bits { template struct list_item { + typedef T value_type; list_item *next; list_item *prev; - T value; + value_type value; }; -template +template class list_iterator//: //public bidirectional_iterator_tag; { - friend class list; - list_item *cur; + friend class ::std::list; public: bool operator == (const list_iterator& other) const { return cur == other.cur; diff --git a/Usermode/Libraries/libc++.so_src/include_exp/new b/Usermode/Libraries/libc++.so_src/include_exp/new new file mode 100644 index 00000000..d5a21db2 --- /dev/null +++ b/Usermode/Libraries/libc++.so_src/include_exp/new @@ -0,0 +1,24 @@ +/* + * Acess2 C++ Library + * - By John Hodge (thePowersGang) + * + * new (header) + * - C++'s new operators + */ +#ifndef _LIBCXX_NEW_ +#define _LIBCXX_NEW_ + +#include "cstddef" + +//extern void* operator new(size_t size) throw (::std::bad_alloc); +//extern void* operator new(size_t size, const std::nothrow_t& nothrow_value) throw(); +extern void* operator new(size_t size, void* ptr) throw(); + +//extern void* operator new[](size_t size) throw (::std::bad_alloc); +//extern void* operator new[](size_t size, const std::nothrow_t& nothrow_value) throw(); +extern void* operator new[](size_t size, void* ptr) throw(); + +#endif + +// vim: ft=cpp + diff --git a/Usermode/Libraries/libc++.so_src/new.cc b/Usermode/Libraries/libc++.so_src/new.cc index 1d09fbc3..f2b2458c 100644 --- a/Usermode/Libraries/libc++.so_src/new.cc +++ b/Usermode/Libraries/libc++.so_src/new.cc @@ -13,11 +13,21 @@ void *operator new( size_t size ) { return malloc( size ); } +void *operator new( size_t size, void* ptr ) +{ + size = size; + return ptr; +} void *operator new[]( size_t size ) { return malloc( size ); } +void *operator new[]( size_t size, void* ptr ) +{ + size = size; + return ptr; +} void operator delete(void *ptr) {