/elec/propeller-clock

To get this branch, use:
bzr branch http://bzr.ed.am/elec/propeller-clock
57 by edam
added ulibc
1
/*	Copyright (C) 2004 Garrett A. Kajmowicz
2
3
	This file is part of the uClibc++ Library.
4
5
	This library is free software; you can redistribute it and/or
6
	modify it under the terms of the GNU Lesser General Public
7
	License as published by the Free Software Foundation; either
8
	version 2.1 of the License, or (at your option) any later version.
9
10
	This library is distributed in the hope that it will be useful,
11
	but WITHOUT ANY WARRANTY; without even the implied warranty of
12
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13
	Lesser General Public License for more details.
14
15
	You should have received a copy of the GNU Lesser General Public
16
	License along with this library; if not, write to the Free Software
17
	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
18
*/
19
20
#include <new>
21
#include <cstddef>
22
#include <cstdlib>
23
#include <iterator_base>
24
#include <utility.h>
25
#include <cstdio>
26
27
#ifndef HEADER_STD_MEMORY
28
#define HEADER_STD_MEMORY 1
29
30
#pragma GCC visibility push(default)
31
32
namespace std{
33
34
template <class T> class allocator;
35
	// Specialize for void:
36
37
template <> class _UCXXEXPORT allocator<void> {
38
public:
39
	typedef void*       pointer;
40
	typedef const void* const_pointer;
41
	typedef void  value_type;
42
	template <class U> struct rebind { typedef allocator<U> other; };
43
};
44
45
template <class T> class _UCXXEXPORT allocator{
46
public:
47
	typedef T value_type;
48
	typedef size_t size_type;
49
	typedef ptrdiff_t difference_type;
50
	
51
	typedef T* pointer;
52
	typedef const T* const_pointer;
53
54
	typedef T& reference;
55
	typedef const T& const_reference;
56
57
	pointer address(reference r) const { return &r; }
58
	const_pointer address(const_reference r) const { return &r; }
59
	
60
	allocator() throw(){}
61
	template <class U> allocator(const allocator<U>& ) throw();
62
	~allocator() throw(){}
63
64
	//Space for n Ts
65
	pointer allocate(size_type n, typename allocator<void>::const_pointer = 0){
66
		return (T*)(::operator new( n * sizeof(T) ));
67
	}
68
	void deallocate(pointer p, size_type){
69
		::operator delete(p);
70
	}
71
72
	//Use placement new to engage the constructor
73
	void construct(pointer p, const T& val) { new((void*)p) T(val); }
74
	void destroy(pointer p){ ((T*)p)->~T(); }	//Call destructor
75
76
	size_type max_size() const throw();
77
	template<class U> struct rebind { typedef allocator<U> other; };
78
79
};
80
81
template <class Out, class T> class _UCXXEXPORT raw_storage_iterator
82
	: public iterator<output_iterator_tag, void, void, void, void>
83
{
84
		Out p;
85
86
public:
87
	explicit raw_storage_iterator(Out pp) : p (pp) {  }
88
	raw_storage_iterator & operator*() { return *this; }
89
	raw_storage_iterator & operator=(const T& val) {
90
		T* pp = &*p;
91
		new(pp) T(val);
92
		return *this;
93
	}
94
95
	raw_storage_iterator & operator++() { ++p; return *this; }
96
	raw_storage_iterator operator++(int) {
97
		raw_storage_iterator t = *this;
98
		++p;
99
		return t;
100
	}
101
};
102
103
template <class T> _UCXXEXPORT pair<T*, ptrdiff_t> get_temporary_buffer(ptrdiff_t n){
104
	pair<T*, ptrdiff_t> retval;
105
	retval.first = static_cast<T*>(malloc(n * sizeof(T)));
106
	if(retval.first == 0){
107
		retval.second = 0;
108
	}else{
109
		retval.second = n;
110
	}
111
	return retval;
112
}
113
114
template <class T> _UCXXEXPORT void return_temporary_buffer(T* p){
115
	free(p);
116
}
117
118
119
template <class T> class _UCXXEXPORT auto_ptr{
120
121
private:
122
	T * object;
123
	template <class Y> struct auto_ptr_ref{
124
		Y * p;
125
	};
126
127
public:
128
129
	typedef T element_type;
130
131
	explicit auto_ptr(T* p =0) throw() : object(p){  }
132
	auto_ptr(auto_ptr& p) throw() : object(p.release()){ }
133
	auto_ptr(auto_ptr_ref<T> r) throw() : object(r.p){
134
		r.p = 0;
135
	}
136
	template<class Y> auto_ptr(auto_ptr<Y>& p) throw() : object(p.release()){ }
137
	auto_ptr& operator=(auto_ptr& p) throw(){
138
		if(&p == this){
139
			return *this;
140
		}
141
		delete object;
142
		object = p.release();
143
		return *this;
144
	}
145
	template<class Y> auto_ptr& operator=(auto_ptr<Y>& p) throw(){
146
		if(&p == this){
147
			return *this;
148
		}
149
		delete object;
150
		object = p.release();
151
		return *this;
152
	}
153
	~auto_ptr(){
154
		delete object;
155
	}
156
157
	T& operator*() const throw(){
158
		return *object;
159
	}
160
	T* operator->() const throw(){
161
		return object;
162
	}
163
	T* get() const throw(){
164
		return object;
165
	}
166
	T* release() throw(){
167
		T * temp(object);
168
		object = 0;
169
		return temp;
170
	}
171
	void reset(T * p=0) throw(){
172
		if(p != object){
173
			delete object;
174
			object = p;
175
		}
176
	}
177
	template<class Y> operator auto_ptr_ref<Y>() throw(){
178
		auto_ptr_ref<Y> retval;
179
		retval.p = object;
180
		object = 0;
181
		return retval;
182
	}
183
	template<class Y> operator auto_ptr<Y>() throw(){
184
		auto_ptr<Y> retval(object);
185
		object = 0;
186
		return retval;
187
	}
188
	
189
};
190
191
}	//namespace std
192
193
#pragma GCC visibility pop
194
195
#endif
196