Add misc/uClibc++ and build hooks in nuttx/

git-svn-id: http://svn.code.sf.net/p/nuttx/code/trunk@5283 42af7a65-404d-4744-a932-0658087f49c3

misc/uClibc++/include/cxx/Makefile

@@ -0,0 +1,13 @@
+TOPDIR=../
+include $(TOPDIR)Rules.mak
+
+all:
+
+clean:
+
+distclean:
+
+HEADERS = $(filter-out .svn CVS Makefile,$(wildcard *))
+install:
+	$(INSTALL) -d $(PREFIX)$(UCLIBCXX_RUNTIME_INCLUDEDIR)
+	$(INSTALL) -m 644 $(HEADERS) $(PREFIX)$(UCLIBCXX_RUNTIME_INCLUDEDIR)

misc/uClibc++/include/cxx/associative_base

@@ -0,0 +1,640 @@
+/*	Copyright (C) 2007 Garrett A. Kajmowicz
+	This file is part of the uClibc++ Library.
+
+	This library is free software; you can redistribute it and/or
+	modify it under the terms of the GNU Lesser General Public
+	License as published by the Free Software Foundation; either
+	version 2.1 of the License, or (at your option) any later version.
+
+	This library is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+	Lesser General Public License for more details.
+
+	You should have received a copy of the GNU Lesser General Public
+	License along with this library; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+
+
+#include<memory>
+#include<utility>
+#include<iterator>
+#include<functional>
+#include<list>
+
+
+#ifndef __STD_HEADER_ASSOCIATIVE_BASE
+#define __STD_HEADER_ASSOCIATIVE_BASE
+
+#pragma GCC visibility push(default)
+
+namespace std{
+
+
+/*
+ *	The basic premise here is that most of the code used by map, multimap, set and
+ *	multiset is really common.  There are a number of interface additions, and
+ *	considerations about how to address multiple entries with the same key.
+ *	The goal is that the tree/storage code should be here, and managing
+ *	single or multiple counts will be left to subclasses.
+ *	Yes, inheritence for the purpose of code sharing is usually a bad idea.
+ *	However, since our goal is to reduce the total amount of code written
+ *	and the overall binary size, this seems to be the best approach possible.
+ */
+
+template<class Key, class ValueType, class Compare = less<Key>, class Allocator = allocator<ValueType> > class __base_associative;
+template<class ValueType, class Compare, class Allocator> class _associative_iter;
+template<class ValueType, class Compare, class Allocator> class _associative_citer;
+
+template<class Key, class ValueType, class Compare = less<Key>, class Allocator = allocator<ValueType> > class __single_associative;
+template<class Key, class ValueType, class Compare = less<Key>, class Allocator = allocator<ValueType> > class __multi_associative;
+
+template<class Key, class ValueType, class Compare, class Allocator> class _UCXXEXPORT __base_associative{
+
+protected:
+
+public:
+	typedef Key							key_type;
+	typedef ValueType						value_type;
+	typedef Compare							key_compare;
+	typedef Allocator						allocator_type;
+	typedef typename Allocator::reference				reference;
+	typedef typename Allocator::const_reference			const_reference;
+	typedef typename Allocator::size_type				size_type;
+	typedef typename Allocator::difference_type			difference_type;
+	typedef typename Allocator::pointer				pointer;
+	typedef typename Allocator::const_pointer			const_pointer;
+	typedef __base_associative<Key, ValueType, Compare, Allocator>	associative_type;
+
+	typedef _associative_iter<value_type, Compare, Allocator>	iterator;
+	typedef _associative_citer<value_type, Compare, Allocator>	const_iterator;
+	typedef typename std::reverse_iterator<iterator>		reverse_iterator;
+	typedef typename std::reverse_iterator<const_iterator>		const_reverse_iterator;
+
+
+	explicit __base_associative(const Compare& comp, const Allocator& A, const key_type (*v_to_k)(const value_type))
+		: c(comp), value_to_key(v_to_k) { }
+protected:
+	__base_associative(const associative_type& x)
+		: c(x.c), backing(x.backing), value_to_key(x.value_to_key) { }
+
+public:
+	~__base_associative(){
+	}
+
+	bool empty() const{
+		return backing.empty();
+	}
+	size_type size() const{
+		return backing.size();
+	}
+	size_type max_size() const{
+		return backing.max_size();
+	}
+
+	iterator begin(){
+		return iterator(backing.begin());
+	}
+
+	const_iterator begin() const{
+		return const_iterator(backing.begin());
+	}
+
+	iterator end() {
+		return iterator(backing.end());
+	}
+
+	const_iterator end() const{
+		return const_iterator(backing.end());
+	}
+
+	reverse_iterator rbegin(){
+		return reverse_iterator(end());
+	}
+
+	const_reverse_iterator rbegin() const{
+		return const_reverse_iterator(end());
+	}
+
+	reverse_iterator rend(){
+		return reverse_iterator(begin());
+	}
+
+	const_reverse_iterator rend() const{
+		return const_reverse_iterator(begin());
+	}
+
+
+	iterator lower_bound(const key_type &x);
+	const_iterator lower_bound(const key_type &x) const;
+	iterator upper_bound(const key_type &x);
+	const_iterator upper_bound(const key_type &x) const;
+
+	pair<iterator,iterator> equal_range(const key_type& x){
+		pair<iterator, iterator> retval;
+		retval.first = lower_bound(x);
+		retval.second = retval.first;
+		while(retval.second != end() && !c(x, value_to_key(*retval.second))){
+			++retval.second;
+		}
+		return retval;
+	}
+	pair<const_iterator,const_iterator> equal_range(const key_type& x) const{
+		pair<const_iterator, const_iterator> retval;
+		retval.first = lower_bound(x);
+		retval.second = retval.first;
+		while(retval.second != end() && !c(x, value_to_key(*retval.second))){
+			++retval.second;
+		}
+		return retval;
+	}
+
+	iterator find(const key_type& x){
+		iterator retval = lower_bound(x);
+		if(retval == end()){
+			return retval;
+		}
+		if(c(x, value_to_key(*retval))){
+			return end();
+		}
+		return retval;
+	}
+	const_iterator find(const key_type& x) const{
+		const_iterator retval = lower_bound(x);
+		if(retval == end()){
+			return retval;
+		}
+		if(c(x, value_to_key(*retval))){
+			return end();
+		}
+		return retval;
+	}
+	size_type count(const key_type& x) const{
+		size_type retval(0);
+		const_iterator first = lower_bound(x);
+		while(first != end() && !c(x, value_to_key(*first))){
+			++retval;
+			++first;
+		}
+		return retval;
+	}
+
+	void clear(){
+		backing.clear();
+	}
+
+	void erase(iterator pos){
+		backing.erase(pos.base_iterator());
+	}
+	size_type erase(const key_type& x){
+		size_type count(0);
+		iterator start = lower_bound(x);
+		iterator end = upper_bound(x);
+		while(start != end){
+			start = backing.erase(start.base_iterator());
+			++count;
+		}
+		return count;
+	}
+	void erase(iterator first, iterator last){
+		while(first != last){
+			backing.erase(first.base_iterator());
+			++first;
+		}
+	}
+
+	key_compare key_comp() const{
+		return c;
+	}
+
+	__base_associative &operator=(const __base_associative & x){
+		c = x.c;
+		backing = x.backing;
+		value_to_key = x.value_to_key;
+		return *this;
+	}
+	bool operator==(const __base_associative & x){
+		return x.backing == backing;
+	}
+	bool operator!=(const __base_associative & x){
+		return !(x.backing == backing);
+	}
+
+protected:
+	void swap(__base_associative & x);
+
+	Compare c;
+	std::list<value_type> backing;
+
+	const key_type (*value_to_key)(const value_type);
+
+};
+
+
+/*
+ * Tree iterators for the base associative class
+ */
+
+template<class ValueType, class Compare, class Allocator> class _associative_citer
+	: public std::iterator<
+		bidirectional_iterator_tag,
+		ValueType,
+		typename Allocator::difference_type,
+		ValueType*,
+		ValueType&
+	>
+{
+protected:
+	typedef std::list<ValueType> listtype;
+
+	typename listtype::const_iterator base_iter;
+	friend class _associative_iter<ValueType, Compare, Allocator>;
+public:
+	_associative_citer() { }
+	_associative_citer(const _associative_citer & m)
+		: base_iter(m.base_iter) { }
+	_associative_citer(const typename listtype::const_iterator & m)
+		: base_iter(m) { }
+	~_associative_citer() { }
+	ValueType operator*() const{
+		return *base_iter;
+	}
+	const ValueType * operator->() const{
+		return &(*base_iter);
+	}
+	_associative_citer & operator=(const _associative_citer & m){
+		base_iter = m.base_iter;
+		return *this;
+	}
+	bool operator==(const _associative_citer & m) const{
+		return m.base_iter == base_iter;
+	}
+	bool operator!=(const _associative_citer & m) const{
+		return m.base_iter != base_iter;
+	}
+	_associative_citer & operator++(){
+		++base_iter;
+		return *this;
+	}
+	_associative_citer operator++(int){
+		//The following approach ensures that we only need to
+		//provide code for ++ in one place (above)
+		_associative_citer temp(base_iter);
+		++base_iter;
+		return temp;
+	}
+	_associative_citer & operator--(){
+		--base_iter;
+		return *this;
+	}
+	_associative_citer operator--(int){
+		//The following approach ensures that we only need to
+		//provide code for -- in one place (above)
+		_associative_citer temp(base_iter);
+		--base_iter;
+		return temp;
+	}
+
+	//This is an implementation-defined function designed to make internals work correctly
+	typename listtype::const_iterator base_iterator(){
+		return base_iter;
+	}
+};
+
+
+template<class ValueType, class Compare, class Allocator> class _associative_iter
+	: public std::iterator<
+		bidirectional_iterator_tag,
+		ValueType,
+		typename Allocator::difference_type,
+		ValueType*,
+		ValueType&
+	>
+{
+protected:
+	typedef std::list<ValueType> listtype;
+
+	typename listtype::iterator base_iter;
+	typedef _associative_citer<ValueType, Compare, Allocator> __associative_citer;
+
+public:
+	_associative_iter() { }
+	_associative_iter(const _associative_iter & m)
+		: base_iter(m.base_iter) { }
+	_associative_iter(const typename listtype::iterator & m)
+		: base_iter(m) { }
+	~_associative_iter() { }
+	const ValueType & operator*() const{
+		return *base_iter;
+	}
+	ValueType & operator*(){
+		return *base_iter;
+	}
+	ValueType * operator->(){
+		return &(*base_iter);
+	}
+	const ValueType * operator->() const{
+		return &(*base_iter);
+	}
+	_associative_iter & operator=(const _associative_iter & m){
+		base_iter = m.base_iter;
+		return *this;
+	}
+	bool operator==(const _associative_iter & m) const{
+		return m.base_iter == base_iter;
+	}
+	bool operator==(const __associative_citer & m) const{
+		return m.base_iter == base_iter;
+	}
+	bool operator!=(const _associative_iter & m) const{
+		return m.base_iter != base_iter;
+	}
+	bool operator!=(const __associative_citer & m) const{
+		return m.base_iter != base_iter;
+	}
+	_associative_iter & operator++(){
+		++base_iter;
+		return *this;
+	}
+	_associative_iter operator++(int){
+		//The following approach ensures that we only need to
+		//provide code for ++ in one place (above)
+		_associative_iter temp(base_iter);
+		++base_iter;
+		return temp;
+	}
+	_associative_iter & operator--(){
+		--base_iter;
+		return *this;
+	}
+	_associative_iter operator--(int){
+		//The following approach ensures that we only need to
+		//provide code for -- in one place (above)
+		_associative_iter temp(base_iter);
+		--base_iter;
+		return temp;
+	}
+	operator __associative_citer() const{
+		return __associative_citer(base_iter);
+	}
+	typename listtype::iterator base_iterator(){
+		return base_iter;
+	}
+	const typename listtype::iterator base_iterator() const{
+		return base_iter;
+	}
+
+};
+
+
+	// The lower_bound code is really crappy linear search.  However, it is a dead
+	// simple implementation (easy to audit).  It can also be easily replaced.
+
+
+	template <class Key, class ValueType, class Compare, class Allocator>
+		typename __base_associative<Key, ValueType, Compare, Allocator>::iterator
+		__base_associative<Key, ValueType, Compare, Allocator>::lower_bound(const key_type &x)
+	{
+		iterator retval = begin();
+		while(retval != end() && c(value_to_key(*retval), x)){
+			++retval;
+		}
+		return retval;
+	}
+
+	template <class Key, class ValueType, class Compare, class Allocator>
+		typename __base_associative<Key, ValueType, Compare, Allocator>::const_iterator
+		__base_associative<Key, ValueType, Compare, Allocator>::lower_bound(const key_type &x) const
+	{
+		const_iterator retval = begin();
+		while(retval != end() && c(value_to_key(*retval), x)){
+			++retval;
+		}
+		return retval;
+	}
+
+	// Upper bound search is linear from the point of lower_bound.  This is likely the best solution
+	// in all but the most pathological of cases.
+
+	template <class Key, class ValueType, class Compare, class Allocator>
+		typename __base_associative<Key, ValueType, Compare, Allocator>::iterator
+		__base_associative<Key, ValueType, Compare, Allocator>::upper_bound(const key_type &x)
+	{
+		iterator retval = lower_bound(x);
+		while(retval != end() && !c(x, value_to_key(*retval))){
+			++retval;
+		}
+		return retval;
+	}
+
+	template <class Key, class ValueType, class Compare, class Allocator>
+		typename __base_associative<Key, ValueType, Compare, Allocator>::const_iterator
+		__base_associative<Key, ValueType, Compare, Allocator>::upper_bound(const key_type &x) const
+	{
+		const_iterator retval = begin();
+		while(retval != end() && !c(x, value_to_key(*retval))){
+			++retval;
+		}
+		return retval;
+	}
+
+
+	template <class Key, class ValueType, class Compare, class Allocator>
+		void __base_associative<Key, ValueType, Compare, Allocator>::swap(__base_associative<Key, ValueType, Compare, Allocator>& m)
+	{
+		Compare n = c;
+		c = m.c;
+		m.c = n;
+
+		m.backing.swap(backing);
+	}
+
+
+template<class Key, class ValueType, class Compare, class Allocator> class _UCXXEXPORT __single_associative :
+	public __base_associative<Key, ValueType, Compare, Allocator>
+{
+protected:
+	typedef __base_associative<Key, ValueType, Compare, Allocator> base;
+	using base::backing;
+
+	using base::c;
+
+public:
+	typedef typename base::key_type                         key_type;
+	typedef typename base::value_type                       value_type;
+	typedef typename base::key_compare                      key_compare;
+	typedef typename base::allocator_type                   allocator_type;
+	typedef typename base::reference                        reference;
+	typedef typename base::const_reference                  const_reference;
+	typedef typename base::iterator                         iterator;
+	typedef typename base::const_iterator                   const_iterator;
+	typedef typename base::size_type                        size_type;
+	typedef typename base::difference_type                  difference_type;
+	typedef typename base::pointer                          pointer;
+	typedef typename base::const_pointer                    const_pointer;
+	typedef typename base::reverse_iterator                 reverse_iterator;
+	typedef typename base::const_reverse_iterator           const_reverse_iterator;
+
+	using base::begin;
+	using base::end;
+	using base::rbegin;
+	using base::rend;
+
+	using base::empty;
+	using base::size;
+	using base::max_size;
+
+	using base::find;
+	using base::count;
+	using base::lower_bound;
+	using base::upper_bound;
+	using base::equal_range;
+
+	using base::operator=;
+	using base::operator==;
+	using base::operator!=;
+
+	explicit __single_associative(const Compare& comp, const Allocator& A, const key_type (*v_to_k)(const value_type))
+		: base(comp, A, v_to_k) { }
+
+	template <class InputIterator> __single_associative(
+		InputIterator first,
+		InputIterator last,
+		const Compare& comp,
+		const Allocator& A,
+		const key_type (*v_to_k)(const value_type)
+	) : base(comp, A, v_to_k) {
+		insert(first, last);
+	}
+
+	pair<iterator, bool> insert(const value_type& x){
+		pair<iterator, bool> retval;
+		iterator location = lower_bound(this->value_to_key(x));
+		retval.second = true;
+		//Empty list or need to insert at end
+		if(end() == location){
+			backing.push_back(x);
+			retval.first = --(end());
+			return retval;
+		}
+		//Something in the list
+		if(c(this->value_to_key(x), this->value_to_key(*location))){
+			location = backing.insert(location.base_iterator(), x);
+			retval.first = location;
+		}else{
+			retval.second = false;
+			retval.first = location;
+		}
+		return retval;
+	}
+
+	iterator insert(iterator position, const value_type& x){
+		// FIXME - this is cheating and probably should be more efficient since we are
+		// now log(n) to find for inserts
+		return insert(x).first;
+	}
+
+	template <class InputIterator> void insert(InputIterator first, InputIterator last){
+		while(first != last){
+			insert(*first);
+			++first;
+		}
+	}
+
+};
+
+
+template<class Key, class ValueType, class Compare, class Allocator> class _UCXXEXPORT __multi_associative :
+	public __base_associative<Key, ValueType, Compare, Allocator>
+{
+protected:
+	typedef __base_associative<Key, ValueType, Compare, Allocator> base;
+	using base::backing;
+
+	using base::c;
+
+public:
+	typedef typename base::key_type                         key_type;
+	typedef typename base::value_type                       value_type;
+	typedef typename base::key_compare                      key_compare;
+	typedef typename base::allocator_type                   allocator_type;
+	typedef typename base::reference                        reference;
+	typedef typename base::const_reference                  const_reference;
+	typedef typename base::iterator                         iterator;
+	typedef typename base::const_iterator                   const_iterator;
+	typedef typename base::size_type                        size_type;
+	typedef typename base::difference_type                  difference_type;
+	typedef typename base::pointer                          pointer;
+	typedef typename base::const_pointer                    const_pointer;
+	typedef typename base::reverse_iterator                 reverse_iterator;
+	typedef typename base::const_reverse_iterator           const_reverse_iterator;
+
+	using base::begin;
+	using base::end;
+	using base::rbegin;
+	using base::rend;
+
+	using base::empty;
+	using base::size;
+	using base::max_size;
+
+	using base::find;
+	using base::count;
+	using base::lower_bound;
+	using base::upper_bound;
+	using base::equal_range;
+
+	using base::operator=;
+	using base::operator==;
+
+
+	explicit __multi_associative(const Compare& comp, const Allocator& A, const key_type (*v_to_k)(const value_type))
+		: base(comp, A, v_to_k) { }
+
+	template <class InputIterator> __multi_associative(
+		InputIterator first,
+		InputIterator last,
+		const Compare& comp,
+		const Allocator& A,
+		const key_type (*v_to_k)(const value_type)
+	) : base(comp, A, v_to_k) {
+		insert(first, last);
+	}
+
+	iterator insert(const value_type& x){
+		iterator location = lower_bound(this->value_to_key(x));
+
+		if(location == begin()){
+			backing.push_front(x);
+			location = begin();
+		}else{
+			location = backing.insert(location.base_iterator(), x);
+		}
+		return location;
+	}
+
+	iterator insert(iterator position, const value_type& x){
+		// FIXME - this is cheating and probably should be more efficient since we are
+		// now log(n) to find for inserts
+		return insert(x);
+	}
+
+	template <class InputIterator> void insert(InputIterator first, InputIterator last){
+		while(first != last){
+			insert(*first);
+			++first;
+		}
+	}
+};
+
+
+
+
+}
+
+#pragma GCC visibility pop
+
+#endif	//__STD_HEADER_ASSOCIATIVE_BASE
+

misc/uClibc++/include/cxx/basic_definitions

@@ -0,0 +1,66 @@
+/*	Copyright (C) 2004 Garrett A. Kajmowicz
+	This file is part of the uClibc++ Library.
+	This library is free software; you can redistribute it and/or
+	modify it under the terms of the GNU Lesser General Public
+	License as published by the Free Software Foundation; either
+	version 2.1 of the License, or (at your option) any later version.
+
+	This library is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+	Lesser General Public License for more details.
+
+	You should have received a copy of the GNU Lesser General Public
+	License along with this library; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+#ifndef __BASIC_DEFINITIONS
+#define __BASIC_DEFINITIONS 1
+
+#include <system_configuration.h>
+
+#pragma GCC visibility push(default)
+
+//The following is used to support GCC symbol visibility patch
+
+#ifdef GCC_HASCLASSVISIBILITY
+	#define _UCXXEXPORT __attribute__ ((visibility("default")))
+	#define _UCXXLOCAL __attribute__ ((visibility("hidden")))
+#else
+	#define _UCXXEXPORT
+	#define _UCXXLOCAL
+
+#endif
+
+#ifdef __GCC__
+#define __UCLIBCXX_NORETURN __attribute__ ((__noreturn__))
+#else
+#define __UCLIBCXX_NORETURN
+#endif
+
+#ifdef __UCLIBCXX_HAS_TLS__
+	#define __UCLIBCXX_TLS __thread
+#else
+	#define __UCLIBCXX_TLS
+#endif
+
+
+
+//Testing purposes
+#define __STRING_MAX_UNITS 65535
+
+namespace std{
+	typedef signed long int streamsize;
+}
+
+#pragma GCC visibility pop
+
+#endif
+
+
+#ifdef __DODEBUG__
+	#define UCLIBCXX_DEBUG 1
+#else
+	#define UCLIBCXX_DEBUG 0
+#endif

misc/uClibc++/include/cxx/bitset

@@ -0,0 +1,423 @@
+/*	Copyright (C) 2004 Garrett A. Kajmowicz
+
+	This file is part of the uClibc++ Library.
+
+	This library is free software; you can redistribute it and/or
+	modify it under the terms of the GNU Lesser General Public
+	License as published by the Free Software Foundation; either
+	version 2.1 of the License, or (at your option) any later version.
+
+	This library is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+	Lesser General Public License for more details.
+
+	You should have received a copy of the GNU Lesser General Public
+	License along with this library; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+#include <basic_definitions>
+#include <cstddef>
+#include <climits>
+#include <func_exception>
+#include <string>
+#include <iosfwd>
+
+#ifndef __STD_BITSET_HEADER
+#define __STD_BITSET_HEADER 1
+
+#pragma GCC visibility push(default)
+
+namespace std{
+	template <size_t N> class bitset;
+
+
+	template <size_t N> bitset<N> operator&(const bitset<N>&, const bitset<N>&);
+	template <size_t N> bitset<N> operator|(const bitset<N>&, const bitset<N>&);
+	template <size_t N> bitset<N> operator^(const bitset<N>&, const bitset<N>&);
+	template <class charT, class traits, size_t N> basic_istream<charT, traits>& 
+		operator>>(basic_istream<charT, traits>& is, bitset<N>& x);
+
+	template <class charT, class traits, size_t N> basic_ostream<charT, traits>& 
+		operator<<(basic_ostream<charT, traits>& os, const bitset<N>& x);
+	
+	//Actual Code
+
+
+	template<size_t N> class _UCXXEXPORT bitset {
+	private:
+		//Number of characters allocated to hold the bits
+		static const size_t WORD_SIZE = CHAR_BIT;		//Use int maybe?
+		static const size_t num_bytes = (N + WORD_SIZE - 1) / WORD_SIZE;
+
+		//From the bit number, figure out which byte we are working with
+		size_t byte_num(size_t bit_num) const{ 
+			if(WORD_SIZE == 8){
+				return (bit_num >> 3);
+			}
+			if(WORD_SIZE == 16){
+				return (bit_num >> 4);
+			}
+			if(WORD_SIZE == 32){
+				return (bit_num >> 5);
+			}
+			if(WORD_SIZE == 64){
+				return (bit_num >> 6);
+			}
+			return bit_num / WORD_SIZE;
+		}
+		//From the bit number, figure out which bit inside the byte we need
+		size_t bit_num(const size_t bit_num) const{
+			return bit_num % WORD_SIZE;
+		}
+
+
+		//Point to the actual data
+		char data[num_bytes];
+	public:
+
+		class _UCXXEXPORT reference {
+			friend class bitset;
+			reference() : bit_num(0), parent(0) {  }
+			size_t bit_num;
+			bitset * parent;
+		public:
+			~reference() {  }
+			reference& operator=(bool x){			// for b[i] = x;
+				parent->set(bit_num, x);
+				return *this;
+			}
+			reference& operator=(const reference& x){	// for b[i] = b[j];
+				parent->set(bit_num, x);
+				return *this;
+			}
+			bool operator~() const{				// flips the bit
+				return !parent->test(bit_num);
+			}
+			operator bool() const{				// for x = b[i];
+				return parent->test(bit_num);
+			}
+			reference& flip(){				// for b[i].flip();
+				parent->flip(bit_num);
+				return *this;
+			}
+		};
+
+		bitset(){
+			reset();
+		}
+		bitset(unsigned long val){
+			reset();
+			size_t count = sizeof(val) * CHAR_BIT;
+			if(count > N){
+				count = N;
+			}
+			for(size_t i = 0; i < count; ++i){
+				set(i, ((val >> i) & 1));
+			}
+		}
+
+		bitset(const bitset & val){
+			for(size_t i = 0; i < num_bytes; ++i){
+				data[i] = val.data[i];
+			}
+		}
+
+		template<class charT, class traits, class Allocator> _UCXXEXPORT
+		explicit bitset(
+			const basic_string<charT,traits,Allocator>& str,
+			typename basic_string<charT,traits,Allocator>::size_type pos = 0,
+			typename basic_string<charT,traits,Allocator>::size_type n =
+			basic_string<charT>::npos
+			
+		){
+			reset();
+			if(n > str.length()){
+				n = str.length();
+			}
+			size_t width = n;
+			if (width + pos > str.length()){
+				width = str.length() - pos;
+			}
+
+			for(size_t i = 0; i < width; ++i){
+				switch(str[pos + width - i - 1]){
+					case '0':
+						break;
+					case '1':
+						set(i);
+						break;
+					default:
+						__throw_invalid_argument();
+				}
+			}
+		}
+
+		bitset<N>& operator&=(const bitset<N>& rhs){
+			for(size_t i =0; i < num_bytes; ++i){
+				data[i] &= rhs.data[i];
+			}
+			return *this;
+		}
+
+		bitset<N>& operator|=(const bitset<N>& rhs){
+			for(size_t i =0; i < num_bytes; ++i){
+				data[i] |= rhs.data[i];
+			}
+			return *this;
+		}
+		bitset<N>& operator^=(const bitset<N>& rhs){
+			for(size_t i=0; i < num_bytes; ++i){
+				data[i] ^= rhs.data[i];
+			}
+			return *this;
+		}
+
+		bitset<N>& operator<<=(size_t pos){
+			for(size_t i = N-1; i >=pos; --i){
+				set(i, test(i - pos));
+			}
+			for(size_t i = 0; i < pos; ++i){
+				reset(i);
+			}
+			return *this;
+		}
+
+		bitset<N>& operator>>=(size_t pos){
+			for(size_t i = 0; i < (N - pos); ++i){
+				set(i, test(i + pos));
+			}
+			for(size_t i = pos; i > 0; --i){
+				reset(N - i);
+			}
+			return *this;
+		}
+
+		bitset<N>& set(){
+			size_t i;
+			for(i = 0; i < N ; ++i){
+				data[byte_num(i)] |= (1<<bit_num(i));
+			}
+			return *this;
+		}
+		bitset<N>& set(size_t pos, int val = true){
+			if(val == true){
+				data[byte_num(pos)] |= (1<<bit_num(pos));
+			}else{
+				data[byte_num(pos)] &= ~(1<<bit_num(pos));
+			}
+			return *this;
+		}
+		bitset<N>& reset(){
+			for(size_t i = 0; i < num_bytes; ++i){
+				data[i] = 0;
+			}
+			return *this;
+		}
+		bitset<N>& reset(size_t pos){
+			data[byte_num(pos)] &= ~(1<<bit_num(pos));
+			return *this;
+		}
+		bitset<N>  operator~() const{
+			bitset<N> retval(*this);
+			retval.flip();
+			return retval;
+		}
+
+		bitset<N>& flip(){
+			for(size_t i = 0; i < num_bytes; ++i){
+				data[i] =  ~data[i];
+			}
+			return *this;
+		}
+		bitset<N>& flip(size_t pos){
+			char temp = data[byte_num(pos)] & (1 << bit_num(pos));
+			if(temp == 0){	//Bit was 0
+				data[byte_num(pos)] |= (1 << bit_num(pos));
+			}else{		//Bit was 1
+				data[byte_num(pos)] &= ~(1<<bit_num(pos));
+			}
+			return *this;
+		}
+
+		reference operator[](size_t pos){   // for b[i];
+			reference retval;
+			retval.parent = this;
+			retval.bit_num = pos;
+			return retval;
+		}
+
+		unsigned long to_ulong() const{
+			if(N > sizeof(unsigned long) * CHAR_BIT){
+				__throw_overflow_error();
+			}
+			unsigned long retval = 0;
+			size_t count = N;
+			for(size_t i = count; i > 0; --i){
+				if(test(i)){
+					retval +=1;
+				}
+				retval<<=1;
+			}
+			if(test(0)){
+				retval +=1;
+			}
+			return retval;
+		}
+
+		template <class charT, class traits, class Allocator>
+			basic_string<charT, traits, Allocator> to_string() const
+		{
+			basic_string<charT, traits, Allocator> retval;
+			retval.reserve(N);
+			for(size_t i = N ; i > 0; --i){
+				if(test(i-1) == true){
+					retval.append("1");
+				}else{
+					retval.append("0");
+				}
+			}
+			return retval;
+		}
+
+
+		size_t count() const{
+			size_t retval = 0;
+			for(size_t i =0; i < N; ++i){
+				if(test(i)){
+					++retval;
+				}
+			}
+			return retval;
+		}
+		size_t size()  const{
+			return N;
+		}
+
+		bitset<N>& operator=(const bitset<N> & rhs){
+			if(&rhs == this){
+				return *this;
+			}
+			for(size_t i = 0; i <= byte_num(N); ++i){
+				data[i] = rhs.data[i];
+			}
+			return *this;
+		}
+
+
+		bool operator==(const bitset<N>& rhs) const{
+			for(size_t i =0; i< N; ++i){
+				if(test(i) != rhs.test(i)){
+					return false;
+				}
+			}
+			return true;
+		}
+
+		bool operator!=(const bitset<N>& rhs) const{
+			for(size_t i =0; i< N; ++i){
+				if(test(i) != rhs.test(i)){
+					return true;
+				}
+			}
+			return false;
+		}
+
+		bool test(size_t pos) const{
+			return (data[byte_num(pos)] & (1<<bit_num(pos)) ) != 0;
+		}
+
+		bool any() const{
+			for(size_t i = 0; i< N; ++i){
+				if(test(i)==true){
+					return true;
+				}
+			}
+			return false;
+		}
+
+		bool none() const{
+			if(any() == true){
+				return false;
+			}
+			return true;
+		}
+
+		bitset<N> operator<<(size_t pos) const{
+			bitset retval(*this);
+			retval<<=pos;
+			return retval;
+		}
+		bitset<N> operator>>(size_t pos) const{
+			bitset retval(*this);
+			retval>>=pos;
+			return retval;
+		}
+	};
+
+	//Non-member functions
+
+
+	template <size_t N> _UCXXEXPORT bitset<N> operator&(const bitset<N>& lhs, const bitset<N>& rhs){
+		bitset<N> retval(lhs);
+		retval &= rhs;
+		return retval;
+	}
+
+	template <size_t N> _UCXXEXPORT bitset<N> operator|(const bitset<N>& lhs, const bitset<N>& rhs){
+		bitset<N> retval(lhs);
+		retval |= rhs;
+		return retval;
+	}
+
+	template <size_t N> _UCXXEXPORT bitset<N> operator^(const bitset<N>& lhs, const bitset<N>& rhs){
+		bitset<N> retval(lhs);
+		retval ^= rhs;
+		return retval;
+	}
+
+	template <class charT, class traits, size_t N> _UCXXEXPORT basic_istream<charT, traits>& 
+		operator>>(basic_istream<charT, traits>& is, bitset<N>& x)
+	{
+		string s;
+		charT c;
+		for(size_t i = 0; i < N; ++i){
+			is.get(c);
+			if(!is.good()){
+				break;
+			}
+			if(c != '1' && c !='0'){
+				is.putback(c);
+				break;
+			}
+			s+=c;
+		}
+		bitset<N> temp(s);
+		x = temp;
+		
+		return is;
+	}
+
+	template <class charT, class traits, size_t N> _UCXXEXPORT basic_ostream<charT, traits>& 
+		operator<<(basic_ostream<charT, traits>& os, const bitset<N>& x)
+	{
+		for(size_t i = N ; i > 0; --i){
+			if(x.test(i-1) == true){
+				os << "1";
+			}else{
+				os << "0";
+			}
+		}
+		return os;
+	}
+
+
+
+
+}
+
+#pragma GCC visibility pop
+
+#endif
+

misc/uClibc++/include/cxx/cfloat

@@ -0,0 +1,30 @@
+/*	Copyright (C) 2004 Garrett A. Kajmowicz
+
+	This file is part of the uClibc++ Library.
+
+	This library is free software; you can redistribute it and/or
+	modify it under the terms of the GNU Lesser General Public
+	License as published by the Free Software Foundation; either
+	version 2.1 of the License, or (at your option) any later version.
+
+	This library is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+	Lesser General Public License for more details.
+
+	You should have received a copy of the GNU Lesser General Public
+	License along with this library; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+#include <setjmp.h>
+
+#ifndef __STD_HEADER_CFLOAT
+#define __STD_HEADER_CFLOAT 1
+
+
+#include <float.h>
+
+
+#endif
+

misc/uClibc++/include/cxx/char_traits

@@ -0,0 +1,215 @@
+//***************************************************************************
+// include/cxx/cerrno
+//
+//   Copyright (C) 2009 Gregory Nutt. All rights reserved.
+//   Author: Gregory Nutt <gnutt@nuttx.org>
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions
+// are met:
+//
+// 1. Redistributions of source code must retain the above copyright
+//    notice, this list of conditions and the following disclaimer.
+// 2. Redistributions in binary form must reproduce the above copyright
+//    notice, this list of conditions and the following disclaimer in
+//    the documentation and/or other materials provided with the
+//    distribution.
+// 3. Neither the name NuttX nor the names of its contributors may be
+//    used to endorse or promote products derived from this software
+//    without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+// COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+// OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+// AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+//
+//***************************************************************************
+//#ifndef __INCLUDE_CXX_CHAR1_TRAITS
+//#define __INCLUDE_CXX_CHAR1_TRAITS
+#include <basic_definitions>
+#include <string.h>
+#include <exception>
+#include <memory>
+
+#ifdef __UCLIBCXX_HAS_WCHAR__
+#include <cwchar>
+#include <cwctype>
+#endif
+
+#ifndef __HEADER_CHAR_TRAITS
+#define __HEADER_CHAR_TRAITS 1
+
+namespace std{
+	/* Inlining all wrapped function calls to shrink the amount of code generated*/	
+	//Typedefs to use for stuff
+	typedef signed int char_traits_off_type;
+
+	//Generic char_traits
+	template<class charT> struct _UCXXEXPORT char_traits { };
+
+	//Specialize for char
+	template<> struct _UCXXEXPORT char_traits<char> {
+		typedef char char_type;
+		typedef short int int_type;
+		typedef char_traits_off_type off_type;
+		typedef char_traits_off_type pos_type;
+		typedef char state_type;
+		
+		inline static void assign(char_type & c, const char_type & d) { c = d; }
+
+		static bool eq(const char_type& c1, const char_type& c2);
+
+		static char_type to_char_type(const int_type & i);
+
+		inline static int_type to_int_type(const char_type & c){
+			return (short int)(unsigned char)c;
+		}
+
+		inline static bool eq_int_type(const int_type & a, const int_type & b){
+			if(a==b){
+				return true;
+			}
+			return false;
+		}
+
+
+		inline static bool lt(const char_type& c1, const char_type& c2){
+			if(strncmp(&c1, &c2, 1) < 0){
+				return true;
+			}
+			return false;
+		}
+
+		inline static char_type* move(char_type* s1, const char_type* s2, size_t n){
+			return (char*) memmove(s1, s2, n);
+		}
+
+		inline static char_type* copy(char_type* s1, const char_type* s2, size_t n){
+			for(unsigned long int i=0; i< n; ++i){
+				assign(s1[i], s2[i]);
+			}
+			return s1 + n;
+		}
+
+		inline static char_type* assign(char_type* s, size_t n, char_type a){
+			return (char *)memset(s, a, n);
+		}
+
+		inline static int compare(const char_type* s1, const char_type* s2, size_t n){
+			return strncmp(s1, s2, n);
+		}
+
+		inline static size_t length(const char_type* s){
+			return wstrlen(s);
+		}
+
+		static const char_type* find(const char_type* s, int n, const char_type& a);
+
+		inline static char_type eos() { return 0; }
+		inline static int_type eof() { return -1; }
+		inline static int_type not_eof(const int_type & i) {
+			if(i == -1){
+				return 0;
+			} else {
+				return i;
+			}
+		}
+		static state_type get_state(pos_type p){
+			p = p;
+			state_type a;
+			return a;
+		}
+	};
+
+
+#ifdef __UCLIBCXX_HAS_WCHAR__
+	template<> struct _UCXXEXPORT char_traits<wchar_t> {
+		typedef wchar_t char_type;
+		typedef wint_t int_type;
+		typedef char_traits_off_type off_type;
+		typedef char_traits_off_type pos_type;
+		typedef mbstate_t state_type;
+
+		static void assign(char_type & c, const char_type & d){ c=d; }
+
+		static char_type to_char_type(const int_type & i){
+			return i;
+		}
+
+		static int_type to_int_type(const char_type & c){
+			return c;
+		}
+
+		inline static bool eq_int_type(const int_type & a, const int_type & b){
+			if(a==b){
+				return true;
+			}
+			return false;
+		}
+
+		inline static bool eq(const char_type& c1, const char_type& c2){
+			if(wcsncmp(&c1, &c2, 1) == 0){
+				return true;
+			}
+			return false;
+		}
+
+		inline static bool lt(const char_type& c1, const char_type& c2){
+			if(wcsncmp(&c1, &c2, 1) < 0){
+				return true;
+			}
+			return false;
+		}
+
+		inline static char_type* move(char_type* s1, const char_type* s2, size_t n){
+			return (char_type*) memmove(s1, s2, n * sizeof(char_type));
+		}
+
+		inline static char_type* copy(char_type* s1, const char_type* s2, size_t n){
+			for(unsigned long int i=0; i< n; ++i){
+				assign(s1[i], s2[i]);
+			}
+			return s1 + n;
+		}
+
+		inline static char_type* assign(char_type* s, size_t n, char_type a){
+			return (char_type *)memset(s, a, n);	/*FIXME*/
+		}
+
+		inline static int compare(const char_type* s1, const char_type* s2, size_t n){
+			return wcsncmp(s1, s2, n);
+		}
+
+		inline static size_t length(const char_type* s){
+			return wcslen(s);
+		}
+
+		static const char_type* find(const char_type* s, int n, const char_type& a);
+
+		inline static char_type eos() { return 0; }
+		inline static int_type eof() { return WEOF; }
+		inline static int_type not_eof(const int_type & i) {
+			if(i == WEOF){
+				return (int_type)0;
+			} else {
+				return i;
+			}
+		}
+		static state_type get_state(pos_type){
+			state_type a;
+			return a;
+		}
+	};
+#endif
+
+}
+
+#endif

misc/uClibc++/include/cxx/clocale

@@ -0,0 +1,30 @@
+/*	Copyright (C) 2005 Garrett A. Kajmowicz
+	This file is part of the uClibc++ Library.
+
+	This library is free software; you can redistribute it and/or
+	modify it under the terms of the GNU Lesser General Public
+	License as published by the Free Software Foundation; either
+	version 2.1 of the License, or (at your option) any later version.
+
+	This library is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+	Lesser General Public License for more details.
+
+	You should have received a copy of the GNU Lesser General Public
+	License along with this library; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+#ifndef __STD_HEADER_CLOCALE
+#define __STD_HEADER_CLOCALE 1
+
+#include <locale.h>
+
+namespace std {
+	using ::lconv;
+	using ::setlocale;
+	using ::localeconv;
+}
+
+#endif // __STD_HEADER_CLOCALE

misc/uClibc++/include/cxx/complex

@@ -0,0 +1,327 @@
+/*	Copyright (C) 2004 Garrett A. Kajmowicz
+
+	This file is part of the uClibc++ Library.
+
+	This library is free software; you can redistribute it and/or
+	modify it under the terms of the GNU Lesser General Public
+	License as published by the Free Software Foundation; either
+	version 2.1 of the License, or (at your option) any later version.
+
+	This library is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+	Lesser General Public License for more details.
+
+	You should have received a copy of the GNU Lesser General Public
+	License along with this library; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+#include <istream>
+#include <ostream>
+
+#ifndef __STD_HEADER_COMPLEX
+#define __STD_HEADER_COMPLEX 1
+
+
+namespace std {
+//	class complex<float>;
+//	class complex<double>;
+//	class complex<long double>;
+
+	template<class T> class _UCXXEXPORT complex{
+	public:
+		typedef T value_type;
+
+		complex(const T& re = T(), const T& im = T()) : r(re), i(im) {  }
+		complex(const complex& c): r(c.r), i(c.i){  }
+		template<class X> complex(const complex<X>& c): r(c.r), i(c.i){  }
+
+		inline T real() const{
+			return r;
+		}
+		inline T imag() const{
+			return i;
+		}
+
+		complex<T>& operator= (const T& v){
+			r = v;
+			i = 0;
+			return *this;
+		}
+		complex<T>& operator+=(const T& v){
+			r +=v;
+			return *this;
+		}
+		complex<T>& operator-=(const T& v){
+			r -=v;
+			return *this;
+		}
+		complex<T>& operator*=(const T& v){
+			r*=v;
+			i*=v;
+			return *this;
+		}
+		complex<T>& operator/=(const T& v){
+			r/=v;
+			i/=v;
+			return *this;
+		}
+		complex& operator=(const complex& v){
+			if(&v != this){
+				r = v.r;
+				i = v.i;
+			}
+			return *this;
+		}
+		template<class X> complex<T>& operator= (const complex<X>& v){
+			r = v.r;
+			i = v.i;
+			return *this;
+		}
+		template<class X> complex<T>& operator+=(const complex<X>& v){
+			r+=v.r;
+			i+=v.i;
+			return *this;
+		}
+		template<class X> complex<T>& operator-=(const complex<X>& v){
+			r-=v.r;
+			i-=v.i;
+			return *this;
+		}
+		template<class X> complex<T>& operator*=(const complex<X>& v){
+			T tempr = r*v.r - i*v.i;
+			T tempi = r*v.i + i*v.r;
+			r = tempr;
+			i = tempi;
+			return *this;
+		}
+		template<class X> complex<T>& operator/=(const complex<X>& v){
+			T tempr = (r*v.r + i*v.i) / (v.r*v.r + v.i*v.i);
+			T tempi = (i*v.r - r*v.i) / (v.r*v.r + v.i*v.i);
+			r = tempr;
+			i = tempi;
+			return *this;
+		}
+	private:
+		T r;
+		T i;
+	};
+
+	template<class T> _UCXXEXPORT complex<T> operator+(const complex<T>& ls, const complex<T>& rs){
+		complex<T> retval(ls);
+		retval += rs;
+		return retval;
+	}
+	template<class T> _UCXXEXPORT complex<T> operator+(const complex<T>& ls, const T& rs){
+		complex<T> retval(ls);
+		ls += rs;
+		return retval;
+	}
+	template<class T> _UCXXEXPORT inline complex<T> operator+(const T& ls, const complex<T>& rs){
+		return rs + ls;
+	}
+	template<class T> _UCXXEXPORT complex<T> operator-(const complex<T>& ls, const complex<T>& rs){
+		complex<T> retval(ls);
+		retval -= rs;
+		return retval;
+	}
+	template<class T> _UCXXEXPORT complex<T> operator-(const complex<T>& ls, const T& rs){
+		complex<T> retval(ls);
+		retval -= rs;
+		return retval;
+	}
+	template<class T> _UCXXEXPORT complex<T> operator-(const T& ls, const complex<T>& rs){
+		complex<T> retval(ls);
+		retval -= rs;
+		return retval;
+	}
+	template<class T> _UCXXEXPORT complex<T> operator*(const complex<T>& ls, const complex<T>& rs){
+		complex<T> retval(ls);
+		retval *= rs;
+		return retval;
+	}
+	template<class T> _UCXXEXPORT complex<T> operator*(const complex<T>& ls, const T& rs){
+		complex<T> retval(ls);
+		retval *= rs;
+		return retval;
+	}
+	template<class T> _UCXXEXPORT complex<T> operator*(const T& ls, const complex<T>& rs){
+		complex<T> retval(ls);
+		retval *=rs;
+		return retval;
+	}
+	template<class T> _UCXXEXPORT complex<T> operator/(const complex<T>& ls, const complex<T>& rs){
+		complex<T> retval(ls);
+		retval/=rs;
+		return retval;
+	}
+	template<class T> _UCXXEXPORT complex<T> operator/(const complex<T>& ls, const T& rs){
+		complex<T> retval(ls);
+		retval/=rs;
+		return retval;
+	}
+	template<class T> _UCXXEXPORT complex<T> operator/(const T& ls, const complex<T>& rs){
+		complex<T> retval(ls);
+		retval/=rs;
+		return retval;
+	}
+	template<class T> _UCXXEXPORT complex<T> operator+(const complex<T>& v){
+		return v;
+	}
+	template<class T> _UCXXEXPORT complex<T> operator-(const complex<T>& v){
+		return complex<T> (-v.real(), -v.imag());
+	}
+	template<class T> _UCXXEXPORT bool operator==(const complex<T>& ls, const complex<T>& rs){
+		if( ls.real() == rs.real() && ls.imag() == rs.image()){
+			return true;
+		}
+		return false;
+	}
+	template<class T> _UCXXEXPORT bool operator==(const complex<T>& ls, const T& rs){
+		if(ls.real() == rs && ls.imag() == T()){
+			return true;
+		}
+		return false;
+	}
+	template<class T> _UCXXEXPORT bool operator==(const T& ls, const complex<T>& rs){
+		if(ls == rs.real() && rs.imag() == T()){
+			return true;
+		}
+		return false;
+	}
+	template<class T> _UCXXEXPORT bool operator!=(const complex<T>& ls, const complex<T>& rs){
+		if(ls == rs){
+			return false;
+		}
+		return true;
+	}
+	template<class T> _UCXXEXPORT bool operator!=(const complex<T>& ls, const T& rs){
+		if(ls == rs){
+			return false;
+		}
+		return true;
+	}
+	template<class T> _UCXXEXPORT bool operator!=(const T& ls, const complex<T>& rs){
+		if(ls == rs){
+			return false;
+		}
+		return true;
+	}
+	template<class T, class charT, class traits> _UCXXEXPORT basic_istream<charT, traits>&
+		 operator>>(basic_istream<charT, traits>& is, complex<T>& v)
+	{
+		T tempr;
+		T tempi;
+		is >> tempr;
+		is.get();
+		is >> tempi;
+		v = complex<T>(tempr, tempi);
+		return is;
+	}
+
+	template<class T, class charT, class traits> _UCXXEXPORT basic_ostream<charT, traits>&
+		 operator<<(basic_ostream<charT, traits>& os, const complex<T>&v)
+	{
+		os << v.real() << ", " << v.imag();
+		return os;
+	}
+
+	template<class T> _UCXXEXPORT T real(const complex<T>& v){
+		return v.real();
+	}
+
+	template<class T> _UCXXEXPORT T imag(const complex<T>& v){
+		return v.imag();
+	}
+
+	template<class T> _UCXXEXPORT T norm(const complex<T>& v){
+		return (v.real() * v.real() + v.imag() * v.imag());
+	}
+
+	template<class T> _UCXXEXPORT complex<T> conj(const complex<T>& v){
+		return complex<T>(v.real(), -v.imag());
+	}
+
+#ifdef __UCLIBCXX_SUPPORT_MATH__	//Can we link with libm?
+
+	template<class T> _UCXXEXPORT T abs(const complex<T>& v){
+		return sqrt(v.real() * v.real() + v.imag() * v.imag());
+	}
+
+	template<class T> _UCXXEXPORT T arg(const complex<T>& v){
+		return atan2(v.imag(), v.real());
+	}
+
+	template<class T> _UCXXEXPORT complex<T> polar(const T& rho, const T& theta){
+		return complex<T>(rho * cos(theta), rho * sin(theta));
+	}
+
+	template<class T> _UCXXEXPORT complex<T> cos  (const complex<T>& v){
+		return complex<T>(cos(v.real()) * cosh(v.imag()), -sin(v.real()) * sinh(v.imag()));
+	}
+
+	template<class T> _UCXXEXPORT complex<T> cosh (const complex<T>& v){
+		return complex<T>(cosh(v.real()) * cos(v.imag()), sinh(v.real()) * sin(v.imag()));
+	}
+
+	template<class T> _UCXXEXPORT complex<T> exp  (const complex<T>& v){
+		return polar(exp(v.real()), v.imag());
+	}
+
+	template<class T> _UCXXEXPORT complex<T> log  (const complex<T>& v){
+		return complex<T>(log(abs(v)), arg(v));
+	}
+
+	template<class T> _UCXXEXPORT complex<T> log10(const complex<T>& v){
+		return (log(v) / log(T(10.0)));
+	}
+
+	template<class T> _UCXXEXPORT complex<T> pow(const complex<T>& v, int p){
+		T rho = pow(abs(v), p);
+		T theta = arg(v);
+		return complex<T>(rho * cos(p * theta), rho * sin(p * theta) );
+	}
+
+	template<class T> _UCXXEXPORT complex<T> pow(const complex<T>& v, const T& p){
+		return polar( pow(abs(v),p), arg(v)*p );
+	}
+
+	template<class T> _UCXXEXPORT complex<T> pow(const complex<T>& v, const complex<T>& p){
+		if(v == T()){
+			//We are using "0" as the value
+			return T();
+		}
+		return exp(p * log(v));
+	}
+
+	template<class T> _UCXXEXPORT complex<T> pow(const T& v, const complex<T>& p){
+		if(v == T()){
+			return T();
+		}
+		return polar(pow(v,p.real()), y.imag() * log(x) );
+	}
+
+	template<class T> _UCXXEXPORT complex<T> sin  (const complex<T>& v){
+		return complex<T>(sin(v.real()) * cosh(v.imag()), cosh(v.real()) * sin(v.imag()));
+	}
+
+	template<class T> _UCXXEXPORT complex<T> sinh (const complex<T>& v){
+		return complext<T>(sinh(v.real()) * cos(v.imag()), cosh(v.real()) * sin(v.imag()) );
+	}
+
+	template<class T> _UCXXEXPORT complex<T> sqrt (const complex<T>&);
+	template<class T> _UCXXEXPORT complex<T> tan  (const complex<T>& v){
+		return sin(v) / cos(v);
+	}
+
+	template<class T> _UCXXEXPORT complex<T> tanh (const complex<T>& v){
+		return sinh(v) / cosh(v);
+	}
+
+#endif
+
+}
+
+#endif
+

misc/uClibc++/include/cxx/csetjmp

@@ -0,0 +1,44 @@
+/*	Copyright (C) 2004 Garrett A. Kajmowicz
+
+	This file is part of the uClibc++ Library.
+
+	This library is free software; you can redistribute it and/or
+	modify it under the terms of the GNU Lesser General Public
+	License as published by the Free Software Foundation; either
+	version 2.1 of the License, or (at your option) any later version.
+
+	This library is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+	Lesser General Public License for more details.
+
+	You should have received a copy of the GNU Lesser General Public
+	License along with this library; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+#include <setjmp.h>
+
+#ifndef __STD_HEADER_CSETJMP
+#define __STD_HEADER_CSETJMP 1
+
+
+//From GCC Header files
+#undef longjmp
+
+// Adhere to section 17.4.1.2 clause 5 of ISO 14882:1998
+#ifndef setjmp
+#define setjmp(env) setjmp (env)
+#endif
+
+//Mine again
+
+
+namespace std{
+	using ::longjmp;
+	using ::jmp_buf;
+}
+
+
+#endif
+

misc/uClibc++/include/cxx/cwchar

@@ -0,0 +1,86 @@
+/*	Copyright (C) 2006 Garrett A. Kajmowicz
+
+	This file is part of the uClibc++ Library.
+	This library is free software; you can redistribute it and/or
+	modify it under the terms of the GNU Lesser General Public
+	License as published by the Free Software Foundation version 2.1
+
+	This library is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+	Lesser General Public License for more details.
+
+	You should have received a copy of the GNU Lesser General Public
+	License along with this library; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+#include <wchar.h>
+#include <basic_definitions>
+
+#ifndef __HEADER_CWCHAR
+#define __HEADER_CWCHAR 1
+
+
+namespace std{
+	using ::mbstate_t;
+	using ::wint_t;
+
+	using ::btowc;
+	using ::fgetwc;
+	using ::fgetws;
+	using ::fputwc;
+	using ::fputws;
+	using ::fwide;
+	using ::fwprintf;
+	using ::fwscanf;
+	using ::getwc;
+	using ::getwchar;
+	using ::mbrlen;
+	using ::mbrtowc;
+	using ::mbsinit;
+	using ::mbsrtowcs;
+	using ::putwc;
+	using ::putwchar;
+	using ::swprintf;
+	using ::swscanf;
+	using ::ungetwc;
+	using ::vfwprintf;
+	using ::vswprintf;
+	using ::vwprintf;
+	using ::wcrtomb;
+	using ::wcscat;
+	using ::wcschr;
+	using ::wcscmp;
+	using ::wcscoll;
+	using ::wcscpy;
+	using ::wcscspn;
+	using ::wcsftime;
+	using ::wcslen;
+	using ::wcsncat;
+	using ::wcsncmp;
+	using ::wcsncpy;
+	using ::wcspbrk;
+	using ::wcsrchr;
+	using ::wcsrtombs;
+	using ::wcsspn;
+	using ::wcsstr;
+	using ::wcstod;
+	using ::wcstok;
+	using ::wcstol;
+	using ::wcstoul;
+	using ::wcsxfrm;
+	using ::wctob;
+	using ::wmemchr;
+	using ::wmemcmp;
+	using ::wmemcpy;
+	using ::wmemmove;
+	using ::wmemset;
+	using ::wprintf;
+	using ::wscanf;
+}
+
+
+
+#endif
+

misc/uClibc++/include/cxx/cwctype

@@ -0,0 +1,106 @@
+// -*- C++ -*- forwarding header.
+
+// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002
+// Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 2, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING.  If not, write to the Free
+// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+// USA.
+
+// As a special exception, you may use this file as part of a free software
+// library without restriction.  Specifically, if other files instantiate
+// templates or use macros or inline functions from this file, or you compile
+// this file and link it with other files to produce an executable, this
+// file does not by itself cause the resulting executable to be covered by
+// the GNU General Public License.  This exception does not however
+// invalidate any other reasons why the executable file might be covered by
+// the GNU General Public License.
+
+//
+// ISO C++ 14882: <cwctype>
+//
+
+/** @file cwctype
+ *  This is a Standard C++ Library file.  You should @c #include this file
+ *  in your programs, rather than any of the "*.h" implementation files.
+ *
+ *  This is the C++ version of the Standard C Library header @c wctype.h,
+ *  and its contents are (mostly) the same as that header, but are all
+ *  contained in the namespace @c std.
+ */
+
+#ifndef _CPP_CWCTYPE
+#define _CPP_CWCTYPE 1
+
+#pragma GCC system_header
+
+//#include <bits/c++config.h>
+
+#ifdef __UCLIBCXX_HAS_WCHAR__
+#include <wctype.h>
+#endif
+
+// Get rid of those macros defined in <wctype.h> in lieu of real functions.
+#undef iswalnum
+#undef iswalpha
+#undef iswblank
+#undef iswcntrl
+#undef iswdigit
+#undef iswgraph
+#undef iswlower
+#undef iswprint
+#undef iswprint
+#undef iswpunct
+#undef iswspace
+#undef iswupper
+#undef iswxdigit
+#undef iswctype  
+#undef towlower
+#undef towupper
+#undef towctrans
+#undef wctrans
+#undef wctype
+
+#if __UCLIBCXX_HAS_WCHAR__
+namespace std
+{
+  using ::wint_t; 	  // cwchar
+
+  using ::wctype_t;
+  using ::wctrans_t;
+
+  using ::iswalnum;
+  using ::iswalpha;
+  using ::iswblank;
+  using ::iswcntrl;
+  using ::iswdigit;
+  using ::iswgraph;
+  using ::iswlower;
+  using ::iswprint;
+  using ::iswprint;
+  using ::iswpunct;
+  using ::iswspace;
+  using ::iswupper;
+  using ::iswxdigit;
+  using ::iswctype;
+  using ::towlower;
+  using ::towupper;
+  using ::towctrans;
+  using ::wctrans;
+  using ::wctype;
+}
+#endif //__ULIBCXX_HAS_WCHAR__
+
+#endif 

misc/uClibc++/include/cxx/deque

@@ -0,0 +1,884 @@
+/*	Copyright (C) 2004 Garrett A. Kajmowicz
+	This file is part of the uClibc++ Library.
+	This library is free software; you can redistribute it and/or
+	modify it under the terms of the GNU Lesser General Public
+	License as published by the Free Software Foundation; either
+	version 2.1 of the License, or (at your option) any later version.
+
+	This library is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+	Lesser General Public License for more details.
+	
+	You should have received a copy of the GNU Lesser General Public
+	License along with this library; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+*/
+
+
+#include <memory>
+#include <iterator>
+#include <stdexcept>
+
+#pragma GCC visibility push(default)
+
+#ifndef __STD_HEADER_DEQUE
+#define __STD_HEADER_DEQUE
+
+
+namespace std{
+	template <class T, class Allocator = allocator<T> > class deque;
+	template <class T, class Allocator> bool operator==(const deque<T,Allocator>& x, const deque<T,Allocator>& y);
+	template <class T, class Allocator> bool operator< (const deque<T,Allocator>& x, const deque<T,Allocator>& y);
+	template <class T, class Allocator> bool operator!=(const deque<T,Allocator>& x, const deque<T,Allocator>& y);
+	template <class T, class Allocator> bool operator> (const deque<T,Allocator>& x, const deque<T,Allocator>& y);
+	template <class T, class Allocator> bool operator>=(const deque<T,Allocator>& x, const deque<T,Allocator>& y);
+	template <class T, class Allocator> bool operator<=(const deque<T,Allocator>& x, const deque<T,Allocator>& y);
+	template <class T, class Allocator> void swap(deque<T,Allocator>& x, deque<T,Allocator>& y);
+
+	template <class T, class Allocator> class _UCXXEXPORT deque {
+	public:
+		friend bool operator==<>(const deque<T, Allocator>& x, const deque<T, Allocator>& y);
+		friend class deque_iter;
+		friend class deque_citer;
+		class deque_iter;
+		class deque_citer;
+
+		typedef typename Allocator::reference		reference;
+		typedef typename Allocator::const_reference	const_reference;
+		typedef deque_iter				iterator;
+		typedef deque_citer				const_iterator;
+		typedef typename Allocator::size_type		size_type;
+		typedef typename Allocator::difference_type	difference_type;
+		typedef T					value_type;
+		typedef Allocator				allocator_type;
+		typedef typename Allocator::pointer		pointer;
+		typedef typename Allocator::const_pointer	const_pointer;
+		typedef std::reverse_iterator<iterator>		reverse_iterator;
+		typedef std::reverse_iterator<const_iterator>	const_reverse_iterator;
+
+		explicit deque(const Allocator& al = Allocator());
+		explicit deque(size_type n, const T& value = T(), const Allocator& al = Allocator());
+		template <class InputIterator> deque(InputIterator first, InputIterator last, const Allocator& = Allocator());
+		deque(const deque<T,Allocator>& x);
+		~deque();
+
+		deque<T,Allocator>& operator=(const deque<T,Allocator>& x);
+		template <class InputIterator> void assign(InputIterator first, InputIterator last);
+		template <class Size, class U> void assign(Size n, const U& u = U());
+		allocator_type get_allocator() const;
+
+		iterator		begin();
+		const_iterator		begin() const;
+		iterator		end();
+		const_iterator		end() const;
+		reverse_iterator	rbegin();
+		const_reverse_iterator	rbegin() const;
+		reverse_iterator	rend();
+		const_reverse_iterator	rend() const;
+
+		size_type		size() const;
+		size_type		max_size() const;
+		void			resize(size_type sz, T c = T());
+		bool			empty() const;
+
+		reference	operator[](size_type n);
+		const_reference	operator[](size_type n) const;
+		reference	at(size_type n);
+		const_reference	at(size_type n) const;
+		reference	front();
+		const_reference	front() const;
+		reference	back();
+		const_reference	back() const;
+
+		void push_front(const T& x);
+		void push_back(const T& x);
+		iterator insert(iterator position, const T& x = T());
+		void     insert(iterator position, size_type n, const T& x);
+		template <class InputIterator> void insert (iterator position, InputIterator first, InputIterator last);
+		void pop_front();
+		void pop_back();
+
+		iterator erase(iterator position);
+		iterator erase(iterator first, iterator last);
+		void     swap(deque<T,Allocator>&);
+		void     clear();
+
+	protected:
+		void reserve(size_type n);
+		inline size_type array_element(size_type deque_element) const{
+			if(deque_element < (data_size - first_element)){
+				return first_element + deque_element;
+			}
+			return deque_element - (data_size - first_element);
+		}
+		inline size_type first_subtract(size_type sub_size) const{
+			if(sub_size > first_element){
+				return (data_size - first_element) - sub_size;
+			}
+			return first_element - sub_size;
+		}
+
+		T * data;
+		size_type data_size;		//Physical size of array
+		size_type elements;		//Elements in array
+		size_type first_element;	//Element number of array 0..n
+		size_type last_element;		//Element number of array 0..n
+		Allocator a;
+
+	};
+
+
+	template<class T, class Allocator> class _UCXXEXPORT deque<T, Allocator>::deque_iter
+		: public std::iterator<
+			random_access_iterator_tag,
+			T,
+			typename Allocator::difference_type,
+			typename Allocator::pointer,
+			typename Allocator::reference
+		>
+	{
+	friend class deque<T, Allocator>;
+	protected:
+		deque<T, Allocator> * container;
+		typename Allocator::size_type element;
+
+	public:
+		deque_iter() : container(0), element(0) {  }
+		deque_iter(const deque_iter & d) : container (d.container), element(d.element) {  }
+		deque_iter(deque<T, Allocator> * c, typename Allocator::size_type e)
+			: container(c), element(e)
+		{
+			return;
+		}
+		~deque_iter() {  }
+		deque_iter & operator=(const deque_iter & d){
+			container = d.container;
+			element = d.element;
+			return *this;
+		}
+		T & operator*(){
+			return container->data[container->array_element(element)];
+		}
+		T * operator->(){
+			return container->data + container->array_element(element);
+		}
+		const T & operator*() const{
+			return container->data[container->array_element(element)];
+		}
+		const T * operator->() const{
+			return container->data + container->array_element(element);
+		}
+		bool operator==(const deque_iter & d) const{
+			if(container == d.container && element == d.element){
+				return true;
+			}
+			return false;
+		}
+		bool operator==(const deque_citer & d) const{
+			if(container == d.container && element == d.element){
+				return true;
+			}
+			return false;
+		}
+		bool operator!=(const deque_iter & d) const{
+			if(container != d.container || element  != d.element){
+				return true;
+			}
+			return false;
+		}
+		bool operator!=(const deque_citer & d) const{
+			if(container != d.container || element  != d.element){
+				return true;
+			}
+			return false;
+		}
+		bool operator<(const deque_iter & d) const{
+			if(element < d.element){
+				return true;
+			}
+			return false;
+		}
+		bool operator<(const deque_citer & d) const{
+			if(element < d.element){
+				return true;
+			}
+			return false;
+		}
+		bool operator<=(const deque_iter & d) const{
+			if(element <= d.element){
+				return true;
+			}
+			return false;
+		}
+		bool operator<=(const deque_citer & d) const{
+			if(element <= d.element){
+				return true;
+			}
+			return false;
+		}
+		bool operator>(const deque_iter & d) const{
+			if(element > d.element){
+				return true;
+			}
+			return false;
+		}
+		bool operator>(const deque_citer & d) const{
+			if(element > d.element){
+				return true;
+			}
+			return false;
+		}
+		bool operator>=(const deque_iter & d) const{
+			if(element >= d.element){
+				return true;
+			}
+			return false;
+		}
+		bool operator>=(const deque_citer & d) const{
+			if(element >= d.element){
+				return true;
+			}
+			return false;
+		}
+		deque_iter & operator++(){
+			++element;
+			return *this;
+		}
+		deque_iter operator++(int){
+			deque_iter temp(container, element);
+			++element;
+			return temp;
+		}
+		deque_iter operator+(typename Allocator::size_type n){
+			deque_iter temp(container, element + n);
+			return temp;
+		}
+		deque_iter & operator+=(typename Allocator::size_type n){
+			element += n;
+			return *this;
+		}
+		deque_iter & operator--(){
+			--element;
+			return *this;
+		}
+		deque_iter operator--(int){
+			deque_iter temp(container, element);
+			--element;
+			return temp;
+		}
+		deque_iter operator-(typename Allocator::size_type n){
+			deque_iter temp(container, element - n);
+			return temp;
+		}
+		deque_iter & operator-=(typename Allocator::size_type n){
+			element -= n;
+			return *this;
+		}
+		typename Allocator::size_type operator-(const deque_iter & d){
+			return element - d.element;
+		}
+
+	};
+
+	template<class T, class Allocator> class _UCXXEXPORT deque<T, Allocator>::deque_citer
+		: public std::iterator<
+			random_access_iterator_tag,
+			T,
+			typename Allocator::difference_type,
+			typename Allocator::const_pointer,
+			typename Allocator::const_reference
+		>
+	{
+	friend class deque<T, Allocator>;
+	protected:
+		const deque<T, Allocator> * container;
+		typename Allocator::size_type element;
+
+	public:
+		deque_citer() : container(0), element(0) {  }
+		deque_citer(const deque_citer & d) : container (d.container), element(d.element) {  }
+		deque_citer(const deque_iter & d) : container (d.container), element(d.element) {  }
+		deque_citer(const deque<T, Allocator> * c, typename Allocator::size_type e)
+			: container(c), element(e)
+		{
+			return;
+		}
+		~deque_citer() {  }
+		deque_citer & operator=(const deque_iter & d){
+			container = d.container;
+			element = d.element;
+			return *this;
+		}
+		const T & operator*() const{
+			return container->data[container->array_element(element)];
+		}
+		const T * operator->() const{
+			return container->data + container->array_element(element);
+		}
+		bool operator==(const deque_citer & d) const{
+			if(container == d.container && element == d.element){
+				return true;
+			}
+			return false;
+		}
+		bool operator==(const deque_iter & d) const{
+			if(container == d.container && element == d.element){
+				return true;
+			}
+			return false;
+		}
+		bool operator!=(const deque_citer & d) const{
+			if(container != d.container || element  != d.element){
+				return true;
+			}
+			return false;
+		}
+		bool operator!=(const deque_iter & d) const{
+			if(container != d.container || element  != d.element){
+				return true;
+			}
+			return false;
+		}
+		bool operator<(const deque_citer & d) const{
+			if(element < d.element){
+				return true;
+			}
+			return false;
+		}
+		bool operator<(const deque_iter & d) const{
+			if(element < d.element){
+				return true;
+			}
+			return false;
+		}
+		bool operator<=(const deque_citer & d) const{
+			if(element <= d.element){
+				return true;
+			}
+			return false;
+		}
+		bool operator<=(const deque_iter & d) const{
+			if(element <= d.element){
+				return true;
+			}
+			return false;
+		}
+		bool operator>(const deque_citer & d) const{
+			if(element > d.element){
+				return true;
+			}
+			return false;
+		}
+		bool operator>(const deque_iter & d) const{
+			if(element > d.element){
+				return true;
+			}
+			return false;
+		}
+		bool operator>=(const deque_citer & d){
+			if(element >= d.element){
+				return true;
+			}
+			return false;
+		}
+		bool operator>=(const deque_iter & d){
+			if(element >= d.element){
+				return true;
+			}
+			return false;
+		}
+		deque_citer & operator++(){
+			++element;
+			return *this;
+		}
+		deque_citer operator++(int){
+			deque_citer temp(container, element);
+			++element;
+			return temp;
+		}
+		deque_citer operator+(typename Allocator::size_type n){
+			deque_citer temp(container, element + n);
+			return temp;
+		}
+		deque_citer & operator+=(typename Allocator::size_type n){
+			element += n;
+			return *this;
+		}
+		deque_citer & operator--(){
+			--element;
+			return *this;
+		}
+		deque_citer operator--(int){
+			deque_citer temp(container, element);
+			--element;
+			return temp;
+		}
+		deque_citer operator-(typename Allocator::size_type n){
+			deque_citer temp(container, element - n);
+			return temp;
+		}
+		deque_citer & operator-=(typename Allocator::size_type n){
+			element -= n;
+			return *this;
+		}
+		typename Allocator::size_type operator-(const deque_citer & d){
+			return element - d.element;
+		}
+
+	};
+
+	template<class T, class Allocator> deque<T, Allocator>::deque(const Allocator& al)
+		: data(0), 
+		data_size(0), elements(0), first_element(0), last_element(0), a(al)
+	{
+		data_size = __UCLIBCXX_STL_BUFFER_SIZE__;
+		data = a.allocate(data_size);
+		first_element = data_size /2;
+		last_element = first_element;
+	}
+
+
+	template<class T, class Allocator> deque<T, Allocator>::deque(
+		size_type n, const T& value, const Allocator& al)
+		: data(0),
+		elements(n), first_element(0), last_element(0), a(al)
+	{
+		data_size = elements + __UCLIBCXX_STL_BUFFER_SIZE__;
+		data = a.allocate(data_size);
+		first_element = (data_size - elements) / 2;
+		last_element = first_element;
+
+		for(n=first_element ; n < last_element; ++n ){
+			a.construct(data+n, value);
+		}
+	}
+
+
+	template<class T, class Allocator> template <class InputIterator> 
+		deque<T, Allocator>::deque(InputIterator first, InputIterator last, const Allocator& al)
+		: data(0),
+		data_size(0), elements(0), first_element(0), last_element(0), a(al)
+	{
+		data_size = __UCLIBCXX_STL_BUFFER_SIZE__;
+		data = a.allocate(data_size);
+		first_element = data_size / 4;	//Note sure how big, but let's add a little space...
+		last_element = first_element;
+		while(first != last){
+			push_back(*first);
+			++first;
+		}
+	}
+
+
+	template<class T, class Allocator> deque<T, Allocator>::deque(const deque<T,Allocator>& x)
+		: data(0),
+		elements(0), first_element(0), last_element(0), a(x.a)
+	{
+		data_size = x.elements + __UCLIBCXX_STL_BUFFER_SIZE__;
+		data = a.allocate(data_size);
+		first_element = (data_size - x.elements) / 2;
+		last_element = first_element;
+		for(size_type i=0; i < x.elements; ++i){
+			push_back(x[i]);
+		}
+	}
+
+
+	template<class T, class Allocator> deque<T, Allocator>::~deque(){
+		clear();
+		a.deallocate(data, data_size);
+	}
+
+	template<class T, class Allocator> deque<T,Allocator>& deque<T, Allocator>::
+		operator=(const deque<T,Allocator>& x)
+	{
+		if(&x == this){
+			return *this;
+		}
+		resize(x.elements);
+		for(size_t i = 0; i < elements; ++i){
+			data[array_element(i)] = x[i];
+		}
+		return *this;
+	}
+
+
+	template<class T, class Allocator> template <class InputIterator> void
+		deque<T, Allocator>::assign(InputIterator first, InputIterator last)
+	{
+		clear();
+		while(first !=last){
+			push_back(*first);
+			++first;
+		}
+	}
+
+
+	template<class T, class Allocator> template <class Size, class U> void
+		deque<T, Allocator>::assign(Size n, const U& u)
+	{
+		if(&u == this){
+			return;
+		}
+		clear();
+		for(size_type i = 0; i < n; ++i){
+			push_back(u);
+		}
+	}
+
+
+	template<class T, class Allocator> typename deque<T, Allocator>::allocator_type 
+		deque<T, Allocator>::get_allocator() const
+	{
+		return a;
+	}
+
+	template<class T, class Allocator> typename
+		deque<T, Allocator>::iterator deque<T, Allocator>::begin()
+	{
+		return deque_iter(this, 0);
+	}
+
+
+	template<class T, class Allocator> typename deque<T, Allocator>::const_iterator
+		deque<T, Allocator>::begin() const
+	{
+		return deque_citer(this, 0);
+	}
+
+	template<class T, class Allocator> typename
+		deque<T, Allocator>::iterator deque<T, Allocator>::end()
+	{
+		return deque_iter(this, elements);
+	}
+
+	template<class T, class Allocator> typename
+		deque<T, Allocator>::const_iterator deque<T, Allocator>::end() const
+	{
+		return deque_citer(this, elements);
+	}
+	
+	template<class T, class Allocator> typename
+		deque<T, Allocator>::reverse_iterator deque<T, Allocator>::rbegin()
+	{
+		return reverse_iterator(end());
+	}
+
+	template<class T, class Allocator> typename
+		deque<T, Allocator>::const_reverse_iterator deque<T, Allocator>::rbegin() const
+	{
+		return const_reverse_iterator(end());
+	}
+
+	template<class T, class Allocator> typename
+		deque<T, Allocator>::reverse_iterator deque<T, Allocator>::rend()
+	{
+		return reverse_iterator(begin());
+	}
+
+	template<class T, class Allocator> typename
+		deque<T, Allocator>::const_reverse_iterator deque<T, Allocator>::rend() const
+	{
+		return const_reverse_iterator(begin());
+	}
+
+	template<class T, class Allocator> typename
+		deque<T, Allocator>::size_type deque<T, Allocator>::size() const
+	{
+		return elements;
+	}
+
+	template<class T, class Allocator> typename
+		deque<T, Allocator>::size_type deque<T, Allocator>::max_size() const
+	{
+		return ((size_type)(-1)) / sizeof(T);
+	}
+
+	template<class T, class Allocator> void deque<T, Allocator>::resize(size_type sz, T c){
+		reserve(sz);
+		while(sz > size()){
+			push_back(c);
+		}
+		while(sz < size()){
+			pop_back();
+		}
+	}
+
+	template<class T, class Allocator> bool deque<T, Allocator>::empty() const{
+		return (elements == 0);
+	}
+
+	template<class T, class Allocator> typename
+		deque<T, Allocator>::reference deque<T, Allocator>::operator[](size_type n)
+	{
+		return data[array_element(n)];
+	}
+
+	template<class T, class Allocator> typename
+		deque<T, Allocator>::const_reference deque<T, Allocator>::operator[](size_type n) const
+	{
+		return data[array_element(n)];
+	}
+
+	template<class T, class Allocator> typename
+		deque<T, Allocator>::reference deque<T, Allocator>::at(size_type n)
+	{
+		if(n > elements){
+			__throw_out_of_range("Out of deque range");
+		}
+		return data[array_element(n)];
+	}
+
+	template<class T, class Allocator> typename
+		deque<T, Allocator>::const_reference deque<T, Allocator>::at(size_type n) const
+	{
+		if(n > elements){
+			__throw_out_of_range("Out of deque range");
+		}
+		return data[array_element(n)];
+	}
+
+	template<class T, class Allocator> typename
+		deque<T, Allocator>::reference deque<T, Allocator>::front()
+	{
+		return data[first_element];
+	}
+
+	template<class T, class Allocator> typename
+		deque<T, Allocator>::const_reference deque<T, Allocator>::front() const
+	{
+		return data[first_element];
+	}
+
+	template<class T, class Allocator> typename
+		deque<T, Allocator>::reference deque<T, Allocator>::back()
+	{
+		return data[array_element(elements-1)];
+	}
+
+	template<class T, class Allocator> typename
+		deque<T, Allocator>::const_reference deque<T, Allocator>::back() const
+	{
+		return data[array_element(elements-1)];
+	}
+	
+	template<class T, class Allocator> void deque<T, Allocator>::push_front(const T& x){
+		reserve(elements + 1);
+		first_element = first_subtract(1);
+		a.construct(data + first_element, x);
+		++elements;
+	}
+
+	template<class T, class Allocator> void deque<T, Allocator>::push_back(const T& x){
+		reserve(elements + 1);
+		a.construct(data + last_element, x);
+		++elements;
+		last_element = array_element(elements);
+	}
+
+	template<class T, class Allocator> typename
+		deque<T, Allocator>::iterator deque<T, Allocator>::insert(iterator position, const T& x)
+	{
+		reserve(elements+1);
+		if(position.element > (elements/2)){
+			//Push all elements back 1
+			push_back(x);
+			for(size_type i = elements-1; i > position.element; --i){
+				at(i) = at(i-1);
+			}
+		}else{
+			//Push all elements forward 1
+			push_front(x);
+			for(size_type i = 0; i < position.element; ++i){
+				at(i) = at(i+1);
+			}
+		}
+		at(position.element) = x;
+		return deque_iter(this, position.element);
+	}
+
+	template<class T, class Allocator> void deque<T, Allocator>::
+		insert(typename deque<T, Allocator>::iterator position, size_type n, const T& x)
+	{
+		reserve(elements + n);
+		for(size_t i =0; i < n; ++i){
+			position = insert(position, x);
+		}
+	}
+
+	template<class T, class Allocator> template <class InputIterator> 
+		void deque<T, Allocator>::insert (iterator position, InputIterator first, InputIterator last)
+	{
+		while(first != last){
+			position = insert(position, *first);
+			++first;
+		}
+	}
+
+	template<class T, class Allocator> void deque<T, Allocator>::pop_front(){
+		if(elements == 0){
+			__throw_out_of_range("deque pop_front");
+		}
+		a.destroy(data + first_element);
+		first_element = array_element(1);
+		--elements;
+	}
+
+	template<class T, class Allocator> void deque<T, Allocator>::pop_back(){
+		last_element = array_element(elements - 1);
+		a.destroy(data + last_element);
+		--elements;
+	}
+
+	template<class T, class Allocator> typename
+		deque<T, Allocator>::iterator deque<T, Allocator>::erase(typename deque<T, Allocator>::iterator position)
+	{
+		if(position.element > (elements /2)){
+			for(size_type i = position.element; i < elements - 1; ++i){
+				at(i) = at(i+1);
+			}
+			pop_back();
+		}else{
+			for(size_type i = position.element; i > 0; --i){
+				at(i) = at(i-1);
+			}
+			pop_front();
+		}
+		return deque_iter(this, position.element);
+	}
+
+	template<class T, class Allocator> typename deque<T, Allocator>::iterator 
+		deque<T, Allocator>::
+		erase(typename deque<T, Allocator>::iterator first, typename deque<T, Allocator>::iterator last)
+	{
+		//Shift backwards
+		size_type num_move = last.element - first.element;
+		if( first.element > (elements - last.element) ){
+			for(size_type i = last.element; i < elements ; ++i){
+				at(i-num_move) = at(i);
+			}
+			for(size_type i = 0; i < num_move ; ++i){
+				pop_back();
+			}
+		}else{
+			for(size_type i = 0; i < first.element ; ++i){
+				at(last.element - i - 1) = at(first.element - i - 1);
+			}
+			for(size_type i = 0; i < num_move ; ++i){
+				pop_front();
+			}
+		}
+		return deque_iter(this, first.element);
+	}
+
+	template<class T, class Allocator> void deque<T, Allocator>::swap(deque<T,Allocator>& x)
+	{
+		T * temp_data;
+		typename deque<T,Allocator>::size_type temp_size;
+
+		//Swap data pointers
+		temp_data = x.data;
+		x.data = data;
+		data = temp_data;
+
+		//Swap array sizes
+		temp_size = x.data_size;
+		x.data_size = data_size;
+		data_size = temp_size;
+
+		//Swap num array elements
+		temp_size  = x.elements;
+		x.elements = elements;
+		elements = temp_size;
+
+		//Swap first_pointer
+		temp_size = x.first_element;
+		x.first_element = first_element;
+		first_element = temp_size;
+
+		//Swap last_pointer
+		temp_size = x.last_element;
+		x.last_element = last_element;
+		last_element = temp_size;
+	}
+
+	template<class T, class Allocator> void deque<T, Allocator>::clear()
+	{
+		while(elements > 0 ){
+			pop_back();
+		}
+	}
+
+
+	template<class T, class Allocator> void deque<T, Allocator>::reserve(typename deque<T, Allocator>::size_type n)
+	{
+		if(data_size >= n){
+			return;
+		}
+
+		size_type size_temp;
+		size_type first_temp;
+		T * data_temp;
+		size_temp = n + __UCLIBCXX_STL_BUFFER_SIZE__;		//Reserve extra 'cause we can
+		data_temp = a.allocate(size_temp);
+	
+		first_temp = (size_temp - elements) / 2;
+		for(size_type i = 0; i < elements; ++i){
+			a.construct(data_temp + first_temp + i, data[array_element(i)]);
+			a.destroy(data + array_element(i));
+		}
+
+		//Now shuffle pointers
+		a.deallocate(data, data_size);
+		data = data_temp;
+		data_size = size_temp;
+		first_element = first_temp;
+		last_element = first_element + elements;
+	}
+
+
+	template <class T, class Allocator> _UCXXEXPORT 
+		bool
+		operator==(const deque<T,Allocator>& x, const deque<T,Allocator>& y)
+	{
+		if(x.elements != y.elements){
+			return false;
+		}
+		for(typename deque<T,Allocator>::size_type i = 0; i < x.elements; ++i){
+			if(x[i] < y[i] || y[i] < x[i]){
+				return false;
+			}
+		}
+		return true;
+	}
+
+	template <class T, class Allocator> bool operator< (const deque<T,Allocator>& x, const deque<T,Allocator>& y);
+	template <class T, class Allocator> _UCXXEXPORT
+		bool
+		operator!=(const deque<T,Allocator>& x, const deque<T,Allocator>& y)
+	{
+		if(x == y){
+			return false;
+		}
+		return true;
+	}
+	template <class T, class Allocator> bool operator> (const deque<T,Allocator>& x, const deque<T,Allocator>& y);
+	template <class T, class Allocator> bool operator>=(const deque<T,Allocator>& x, const deque<T,Allocator>& y);
+	template <class T, class Allocator> bool operator<=(const deque<T,Allocator>& x, const deque<T,Allocator>& y);
+	template <class T, class Allocator> _UCXXEXPORT void swap(deque<T,Allocator>& x, deque<T,Allocator>& y){
+		x.swap(y);
+	}
+
+
+
+}
+
+#pragma GCC visibility pop
+
+#endif
+
+
+
+

misc/uClibc++/include/cxx/exception

@@ -0,0 +1,120 @@
+// Exception Handling support header for -*- C++ -*-
+
+// Copyright (C) 1995, 1996, 1997, 1998, 2000, 2001, 2002
+// Free Software Foundation
+//
+// This file is part of GNU CC.
+//
+// GNU CC is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2, or (at your option)
+// any later version.
+//
+// GNU CC is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with GNU CC; see the file COPYING.  If not, write to
+// the Free Software Foundation, 59 Temple Place - Suite 330,
+// Boston, MA 02111-1307, USA.
+
+// As a special exception, you may use this file as part of a free software
+// library without restriction.  Specifically, if other files instantiate
+// templates or use macros or inline functions from this file, or you compile
+// this file and link it with other files to produce an executable, this
+// file does not by itself cause the resulting executable to be covered by
+// the GNU General Public License.  This exception does not however
+// invalidate any other reasons why the executable file might be covered by
+// the GNU General Public License.
+
+/** @file exception
+ *  This header defines several types and functions relating to the
+ *  handling of exceptions in a C++ program.
+ */
+
+#ifndef __EXCEPTION__
+#define __EXCEPTION__
+
+#include <basic_definitions>
+
+extern "C++" {
+
+namespace std
+{
+  /**
+   *  @brief Base class for all library exceptions.
+   *
+   *  This is the base class for all exceptions thrown by the standard
+   *  library, and by certain language expressions.  You are free to derive
+   *  your own %exception classes, or use a different hierarchy, or to
+   *  throw non-class data (e.g., fundamental types).
+   */
+  class exception
+  {
+  public:
+    exception() throw() { }
+    virtual ~exception() throw();
+    /** Returns a C-style character string describing the general cause
+     *  of the current error.  */
+    virtual const char* what() const throw();
+  };
+
+  /** If an %exception is thrown which is not listed in a function's
+   *  %exception specification, one of these may be thrown.  */
+  class bad_exception : public exception
+  {
+  public:
+    bad_exception() throw() { }
+    // This declaration is not useless:
+    // http://gcc.gnu.org/onlinedocs/gcc-3.0.2/gcc_6.html#SEC118
+    virtual ~bad_exception() throw();
+  };
+
+  /// If you write a replacement %terminate handler, it must be of this type.
+  typedef void (*terminate_handler) ();
+  /// If you write a replacement %unexpected handler, it must be of this type.
+  typedef void (*unexpected_handler) ();
+
+  /// Takes a new handler function as an argument, returns the old function.
+  terminate_handler set_terminate(terminate_handler) throw();
+  /** The runtime will call this function if %exception handling must be
+   *  abandoned for any reason.  */
+  void terminate() __UCLIBCXX_NORETURN;
+
+  /// Takes a new handler function as an argument, returns the old function.
+  unexpected_handler set_unexpected(unexpected_handler) throw();
+  /** The runtime will call this function if an %exception is thrown which
+   *  violates the function's %exception specification.  */
+  void unexpected() __UCLIBCXX_NORETURN;
+
+  /** [18.6.4]/1:  "Returns true after completing evaluation of a
+   *  throw-expression until either completing initialization of the
+   *  exception-declaration in the matching handler or entering @c unexpected()
+   *  due to the throw; or after entering @c terminate() for any reason
+   *  other than an explicit call to @c terminate().  [Note: This includes
+   *  stack unwinding [15.2].  end note]"
+   *
+   *  2:  "When @c uncaught_exception() is true, throwing an %exception can
+   *  result in a call of @c terminate() (15.5.1)."
+   */
+  bool uncaught_exception() throw();
+} // namespace std
+
+namespace __gnu_cxx
+{
+  /** A replacement for the standard terminate_handler which prints more
+      information about the terminating exception (if any) on stderr.  Call
+      @code
+        std::set_terminate (__gnu_cxx::__verbose_terminate_handler)
+      @endcode
+      to use.  For more info, see
+      http://gcc.gnu.org/onlinedocs/libstdc++/19_diagnostics/howto.html#4
+  */
+  void __verbose_terminate_handler ();
+} // namespace __gnu_cxx
+
+} // extern "C++"
+
+#endif

misc/uClibc++/include/cxx/fstream

@@ -0,0 +1,676 @@
+/*	Copyright (C) 2004 Garrett A. Kajmowicz
+
+	This file is part of the uClibc++ Library.
+	This library is free software; you can redistribute it and/or
+	modify it under the terms of the GNU Lesser General Public
+	License as published by the Free Software Foundation; either
+	version 2.1 of the License, or (at your option) any later version.
+
+	This library is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+	Lesser General Public License for more details.
+
+	You should have received a copy of the GNU Lesser General Public
+	License along with this library; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+#ifndef __STD_HEADER_FSTREAM 
+#define __STD_HEADER_FSTREAM 1
+
+
+#include<basic_definitions>
+
+#include <cstdio>
+#include <cstdlib>
+#include <streambuf>
+#include <istream>
+#include <ostream>
+#include <char_traits>
+
+#include <unistd.h>
+#include <fcntl.h>
+#include <errno.h>
+
+#ifdef __UCLIBCXX_HAS_WCHAR__
+#include <cwchar>
+#include <cwctype>
+#endif //__UCLIBCXX_HAS_WCHAR__
+
+#pragma GCC visibility push(default)
+
+namespace std{
+
+	template <class C, class T> class basic_filebuf;
+
+	typedef basic_filebuf<char>    filebuf;
+#ifdef __UCLIBCXX_HAS_WCHAR__
+	typedef basic_filebuf<wchar_t> wfilebuf;
+#endif
+
+
+	template <class charT, class traits> class _UCXXEXPORT basic_filebuf
+		: public basic_streambuf<charT,traits>
+	{
+#ifdef __UCLIBCXX_SUPPORT_CDIR__
+		friend ios_base::Init::Init();	//Needed for cout/cin stuff
+#endif
+	public:
+		// Types (inherited from basic_streambuf:
+		typedef typename basic_streambuf<charT, traits>::char_type	char_type;
+		typedef typename basic_streambuf<charT, traits>::int_type 	int_type;
+		typedef typename basic_streambuf<charT, traits>::pos_type	pos_type;
+		typedef typename basic_streambuf<charT, traits>::off_type	off_type;
+		typedef traits							traits_type;
+
+		//Constructors/destructor:
+
+		_UCXXEXPORT basic_filebuf()	: basic_streambuf<charT, traits>(), fp(0), pbuffer(0), gbuffer(0)
+		{
+			append=false;
+			pbuffer = new char_type[__UCLIBCXX_IOSTREAM_BUFSIZE__];
+			gbuffer = new char_type[__UCLIBCXX_IOSTREAM_BUFSIZE__];
+
+			this->setp(pbuffer, pbuffer + __UCLIBCXX_IOSTREAM_BUFSIZE__);
+			//Position get buffer so that there is no data available
+			this->setg(gbuffer, gbuffer + __UCLIBCXX_IOSTREAM_BUFSIZE__,
+				gbuffer + __UCLIBCXX_IOSTREAM_BUFSIZE__);
+		}
+
+
+		_UCXXEXPORT virtual ~basic_filebuf(){
+			sync();
+			close();
+			delete [] pbuffer;
+			delete [] gbuffer;
+			pbuffer = 0;
+			gbuffer = 0;
+		}
+
+
+		//Members:
+
+		_UCXXEXPORT bool is_open() const{
+			if(fp == 0){
+				return false;
+			}
+			return true;
+		}
+
+		_UCXXEXPORT basic_filebuf<charT,traits>* open(const char* s, ios_base::openmode mode){
+			bool move_end = (mode & ios_base::ate) != 0;
+			if(is_open() !=false){	//Must call close() first
+				return 0;
+			}
+			basic_streambuf<charT,traits>::openedFor = mode;
+			mode = mode & ~ios_base::ate;
+
+			if(mode == ios_base::out || mode == (ios_base::out | ios_base::trunc)){
+				fp = fopen(s, "w" );
+			}else if((mode & ios_base::app) && ! (mode & ios_base::trunc)){
+				if(mode & ios_base::binary){
+					if(mode & ios_base::in){
+						fp = fopen(s, "a+b");
+					}else{
+						fp = fopen(s, "ab");
+					}
+				}else{
+					if(mode & ios_base::in){
+						fp = fopen(s, "a+");
+					}else{
+						fp = fopen(s, "a");
+					}
+				}
+			}else if(mode == ios_base::in){
+				fp = fopen(s, "r");
+			}else if(mode == (ios_base::in | ios_base::out)){
+				fp = fopen(s, "r+");
+			}else if(mode == (ios_base::in | ios_base::out | ios_base::trunc)){
+				fp = fopen(s, "w+");
+			}else if(mode == (ios_base::binary | ios_base::out)){
+				fp = fopen(s, "wb");
+			}else if(mode == (ios_base::in | ios_base::binary)){
+				fp = fopen(s, "rb");
+			}else if(mode == (ios_base::in | ios_base::binary | ios_base::out)){
+				fp = fopen(s, "r+b");
+			}else if(mode==(ios_base::binary | ios_base::out | ios_base::trunc)){
+				fp = fopen(s, "w+b");
+			}else if(mode == (ios_base::in | ios_base::binary | ios_base::out | ios_base::trunc)){
+				fp = fopen(s, "w+b");
+			}
+
+			if(fp == 0){
+				return 0;
+			}
+			if(ferror(fp)){
+				fclose(fp);
+				fp=0;
+				return 0;
+			}
+			int retval = 0;
+
+			//Check to make sure the stream is good
+			if(move_end == true){
+				retval = fseek(fp, 0, SEEK_END);
+			}else{
+				retval = fseek(fp, 0, SEEK_SET);
+			}
+			if(retval!=0){		//Seek error
+				fclose(fp);
+				fp=0;
+				return 0;
+			}
+
+			basic_streambuf<charT,traits>::mgnext = basic_streambuf<charT,traits>::mgend;
+
+			return this;
+		}
+		_UCXXEXPORT basic_filebuf<charT,traits>* close(){
+			if(fp != 0 && fp != stdin && fp != stdout && fp !=stderr ){
+				overflow();
+				sync();
+				int retval = fclose(fp);
+				if(retval !=0){		//Error of some sort
+					return 0;
+				}
+				fp=0;
+			}
+			return this;
+		}
+	protected:
+		_UCXXEXPORT basic_filebuf(const basic_filebuf<charT,traits> &){ }
+		_UCXXEXPORT basic_filebuf<charT,traits> & operator=(const basic_filebuf<charT,traits> &){ return *this; }
+
+		//Overridden virtual functions:
+
+		virtual _UCXXEXPORT int showmanyc(){
+			return basic_streambuf<charT,traits>::egptr() - basic_streambuf<charT,traits>::gptr();
+		}
+		virtual _UCXXEXPORT int_type underflow(){
+			/* Some variables used internally:
+			   Buffer pointers:
+			   charT * mgbeg;
+			   charT * mgnext;
+			   charT * mgend;
+
+			   eback() returns mgbeg
+			   gptr()  returns mgnext
+			   egptr() returns mgend
+
+			   gbump(int n) mgnext+=n
+
+			*/
+
+			if(!is_open()){
+				return traits::eof();
+			}
+
+			if(basic_streambuf<charT,traits>::eback() == 0){
+				//No buffer, so...
+				charT c;
+				int retval;
+				retval = fread(&c, sizeof(charT), 1, fp);
+
+				if(retval == 0 || feof(fp) || ferror(fp) ){
+					return traits::eof();
+				}
+				return traits::to_int_type(c);
+			}
+
+			if(basic_streambuf<charT,traits>::eback() == basic_streambuf<charT,traits>::gptr()){	//Buffer is full
+				return traits::to_int_type(*basic_streambuf<charT,traits>::gptr());
+			}
+			//Shift entire buffer back to the begining
+			size_t offset = basic_streambuf<charT,traits>::gptr() - basic_streambuf<charT,traits>::eback();
+			size_t amountData = basic_streambuf<charT,traits>::egptr() - basic_streambuf<charT,traits>::gptr();
+
+			for(charT * i = basic_streambuf<charT,traits>::gptr(); i < basic_streambuf<charT,traits>::egptr(); ++i){
+				*(i-offset) = *i;
+			}
+
+			size_t retval = 0;
+			//Save operating flags from file descriptor
+			int fcntl_flags = fcntl(fileno(fp), F_GETFL);
+			retval = 0;
+
+			//Set to non_blocking mode
+			fcntl(fileno(fp), F_SETFL, fcntl_flags | O_NONBLOCK);
+
+			//Fill rest of buffer
+			retval = fread(basic_streambuf<charT,traits>::egptr() - 
+				basic_streambuf<charT,traits>::gptr() + basic_streambuf<charT,traits>::eback(),
+				sizeof(charT),
+				offset,
+				fp
+			);
+
+			//Clear problems where we didn't read in enough characters
+			if(EAGAIN == errno){
+				clearerr(fp);
+			}
+
+			//Restore file descriptor clase
+			fcntl(fileno(fp), F_SETFL, fcntl_flags);
+
+			//Now we are going to make sure that we read in at least one character.  The hard way.
+			if(retval == 0){
+				fcntl_flags = fcntl(fileno(fp), F_GETFL);
+				//Set to blocking mode
+				fcntl(fileno(fp), F_SETFL, fcntl_flags & ~O_NONBLOCK);
+
+				retval = fread(basic_streambuf<charT,traits>::egptr() - 
+					basic_streambuf<charT,traits>::gptr() + basic_streambuf<charT,traits>::eback(),
+					sizeof(charT),
+					1,
+					fp
+				);
+
+				//Restore file descriptor clase
+				fcntl(fileno(fp), F_SETFL, fcntl_flags);
+
+			}
+
+			if(retval !=offset){ //Slide buffer forward again
+				for(size_t i = 0; i < amountData + retval; ++i){
+					*(basic_streambuf<charT,traits>::egptr() - i - 1) =
+						*(basic_streambuf<charT,traits>::eback() + amountData + retval - i - 1);
+				}
+			}
+
+			basic_streambuf<charT,traits>::mgnext -= retval;
+
+			if( (retval <= 0 && feof(fp)) || ferror(fp) ){
+				return traits::eof();
+			}
+
+			return traits::to_int_type(*basic_streambuf<charT,traits>::gptr());
+		}
+		virtual _UCXXEXPORT int_type uflow(){
+			bool dobump = (basic_streambuf<charT,traits>::gptr() != 0);
+			int_type retval = underflow();
+			if(dobump){
+				basic_streambuf<charT,traits>::gbump(1);
+			}
+			return retval;
+		}
+		virtual _UCXXEXPORT int_type pbackfail(int_type c = traits::eof()){
+			if(is_open() == false || 
+				basic_streambuf<charT,traits>::gptr() == basic_streambuf<charT,traits>::eback())
+			{
+				return traits::eof();
+			}
+			if(traits::eq_int_type(c,traits::eof()) == false){
+				if(traits::eq(traits::to_char_type(c), basic_streambuf<charT,traits>::gptr()[-1]) == true){
+					basic_streambuf<charT,traits>::gbump(-1);
+				}else{
+					basic_streambuf<charT,traits>::gbump(-1);
+					basic_streambuf<charT,traits>::gptr()[0] = c;
+				}
+				return c;
+			}else{
+				basic_streambuf<charT,traits>::gbump(-1);
+				return traits::not_eof(c);
+			}
+		}
+
+		virtual _UCXXEXPORT int_type overflow(int_type c = traits::eof()){
+			if(is_open() == false){
+				//Can't do much
+				return traits::eof();
+			}
+			if(basic_streambuf<charT,traits>::pbase() == 0){		//Unbuffered - elliminate dupe code below
+				if(fputc(c, fp) == EOF){
+					return traits::eof();
+				}
+				return c;
+			}
+			if(basic_streambuf<charT,traits>::pbase() == 0 && traits::eq_int_type(c,traits::eof()) ){
+				//Nothing to flush
+				return traits::not_eof(c);
+			}
+			size_t r = basic_streambuf<charT,traits>::pptr() - basic_streambuf<charT,traits>::pbase();
+
+			if( r == 0 && traits::eq_int_type(c,traits::eof()) ){
+				return traits::not_eof(c);
+			}else if (r == 0 ){
+				if(fputc(c, fp) == EOF){
+					return traits::eof();
+				}
+				return c;
+			}
+
+			size_t totalChars = r;
+
+			char_type *buffer = 0;
+			if(traits::eq_int_type(c,traits::eof())){
+				buffer = new char_type[r];
+			}else{
+				buffer = new char_type[r+1];
+				buffer[r] = c;
+				totalChars++;
+			}
+
+			traits::copy(buffer, basic_streambuf<charT,traits>::pbase(), r);
+//			memcpy(buffer, basic_streambuf<charT,traits>::pbase(), r);
+
+			size_t retval = fwrite(buffer, sizeof(charT), totalChars, fp);
+			if(retval !=totalChars){
+				if(retval == 0){
+					delete [] buffer;
+					return traits::eof();
+				}
+				basic_streambuf<charT,traits>::pbump(-retval);
+				fprintf(stderr, "***** Did not write the full buffer out.  Should be: %d, actually: %d\n",
+					 totalChars, retval);
+			}else{
+				basic_streambuf<charT,traits>::pbump(-r);
+			}
+
+			delete [] buffer;
+			return traits::not_eof(c);
+		}
+
+		virtual _UCXXEXPORT basic_streambuf<charT,traits>* setbuf(char_type* s, streamsize n){
+			if(s == 0 && n == 0){	//Unbuffered
+				if(pbuffer !=0){
+					delete [] pbuffer;
+				}
+				if(gbuffer !=0){
+					delete [] gbuffer;
+				}
+				pbuffer = 0;
+				gbuffer = 0;
+			}else if(basic_streambuf<charT,traits>::gptr() !=0 && 
+				basic_streambuf<charT,traits>::gptr()==basic_streambuf<charT,traits>::egptr())
+			{
+				delete [] pbuffer;
+				pbuffer = s;
+			}
+			return this;
+		}
+		virtual _UCXXEXPORT pos_type seekoff(off_type off, ios_base::seekdir way, 
+			ios_base::openmode = ios_base::in | ios_base::out)
+		{
+			if(is_open() == false){
+				return -1;
+			}
+			int whence = SEEK_SET;	// if(way == basic_ios<charT>::beg)
+			off_type position = off;
+
+			if(way == basic_ios<charT>::cur){
+				whence = SEEK_CUR;
+				position -= (basic_streambuf<charT,traits>::egptr() - basic_streambuf<charT,traits>::gptr());
+			}else if(way == basic_ios<charT>::end){
+				whence = SEEK_END;
+			}
+
+			sync();
+
+			int retval = fseek(
+				fp,
+				sizeof(charT)*(position),
+				whence
+			);
+
+			//Invalidate read buffer
+			basic_streambuf<charT,traits>::gbump(
+				basic_streambuf<charT,traits>::egptr() - basic_streambuf<charT,traits>::gptr()
+			);
+
+			if(-1 != retval){
+				retval = ftell(fp);
+			}
+
+			return retval;
+		}
+		virtual _UCXXEXPORT pos_type seekpos(pos_type sp, ios_base::openmode = ios_base::in | ios_base::out){
+			if(is_open() == false){
+				return -1;
+			}
+			sync();
+
+			int retval = fseek(fp,sizeof(charT)* sp, SEEK_SET);
+
+			//Invalidate read buffer
+			basic_streambuf<charT,traits>::gbump(basic_streambuf<charT,traits>::egptr() - basic_streambuf<charT,traits>::gptr());
+			if(retval > -1){
+				return sp;
+			}
+			return -1;
+		}
+		virtual _UCXXEXPORT int sync(){
+			if(pbuffer !=0){
+				if(overflow() == traits::eof()){
+					return -1;
+				}
+			}
+			if(0 != fp && 0 != fflush(fp)){
+				return -1;
+			}
+			return 0;
+		}
+		virtual _UCXXEXPORT void imbue(const locale&){
+			return;
+		}
+
+
+		virtual _UCXXEXPORT streamsize xsputn(const char_type* s, streamsize n){
+			if(is_open() == false){
+				return 0;
+			}
+			//Check to see if buffered
+
+			//Check to see if we can buffer the data
+			streamsize buffer_avail = basic_streambuf<charT,traits>::epptr() - basic_streambuf<charT,traits>::pptr();
+
+			if(n > buffer_avail){		//Flush buffer and write directly
+				overflow();	//Flush the buffer
+				return fwrite(s, sizeof(charT), n, fp);
+			}
+
+			//Add to buffer to be written later
+
+			traits::copy(basic_streambuf<charT,traits>::pptr(), s, n);
+			basic_streambuf<charT,traits>::pbump(n);
+
+			return n;
+		}
+
+		FILE * fp;
+		char_type * pbuffer;
+		char_type * gbuffer;
+		bool append;
+	};
+
+
+#ifdef __UCLIBCXX_HAS_WCHAR__
+
+template <> _UCXXEXPORT basic_filebuf<wchar_t, char_traits<wchar_t> >::int_type
+	basic_filebuf<wchar_t, char_traits<wchar_t> >::overflow(int_type c);
+
+template <> _UCXXEXPORT basic_filebuf<wchar_t, char_traits<wchar_t> >::int_type
+	basic_filebuf<wchar_t, char_traits<wchar_t> >::underflow();
+
+#endif //__UCLIBCXX_HAS_WCHAR__
+
+
+
+#ifdef __UCLIBCXX_EXPAND_FSTREAM_CHAR__
+#ifndef __UCLIBCXX_COMPILE_FSTREAM__
+
+#ifdef __UCLIBCXX_EXPAND_CONSTRUCTORS_DESTRUCTORS__
+
+	template <> _UCXXEXPORT filebuf::basic_filebuf();
+	template <> _UCXXEXPORT filebuf::~basic_filebuf();
+
+#endif // __UCLIBCXX_EXPAND_CONSTRUCTORS_DESTRUCTORS__
+
+	template <> _UCXXEXPORT filebuf::int_type filebuf::pbackfail(filebuf::int_type c);
+	template <> _UCXXEXPORT filebuf * filebuf::open(const char* s, ios_base::openmode mode);
+	template <> _UCXXEXPORT filebuf * filebuf::close();
+	template <> _UCXXEXPORT filebuf::int_type filebuf::overflow(filebuf::int_type c);
+	template <> _UCXXEXPORT filebuf::int_type filebuf::underflow ();
+
+	template <> _UCXXEXPORT basic_streambuf<char, char_traits<char> > * filebuf::setbuf(char * s, streamsize n);
+	template <> _UCXXEXPORT streamsize filebuf::xsputn(const char* s, streamsize n);
+
+#endif
+#endif
+
+
+	template <class charT, class traits> class _UCXXEXPORT basic_ifstream
+		: public basic_istream<charT,traits>
+	{
+	public:
+		typedef charT char_type;
+		typedef typename traits::int_type int_type;
+		typedef typename traits::pos_type pos_type;
+		typedef typename traits::off_type off_type;
+
+		_UCXXEXPORT basic_ifstream(): basic_ios<charT, traits>(&sb), basic_istream<charT,traits>(&sb){
+			//Passing the address of sb
+		}
+		explicit _UCXXEXPORT basic_ifstream(const char* s, ios_base::openmode mode = ios_base::in)
+			: basic_ios<charT, traits>(&sb), basic_istream<charT,traits>(&sb)
+		{
+			if(sb.open(s, mode) == 0){
+				basic_ios<charT,traits>::setstate(ios_base::failbit);
+			}
+		}
+
+		virtual _UCXXEXPORT ~basic_ifstream(){
+
+		}
+
+		_UCXXEXPORT basic_filebuf<charT,traits>* rdbuf() const{
+			return (basic_filebuf<charT,traits>*)&sb;
+		}
+		_UCXXEXPORT bool is_open() const{
+			return sb.is_open();
+		}
+		_UCXXEXPORT void open(const char* s, ios_base::openmode mode = ios_base::in){
+			if(sb.open(s, mode) == 0){
+				basic_ios<charT,traits>::setstate(ios_base::failbit);
+			}
+		}
+		_UCXXEXPORT void close(){
+			sb.close();
+		}
+	private:
+		basic_filebuf<charT,traits> sb;
+	};
+
+
+	template <class charT, class traits> class _UCXXEXPORT basic_ofstream
+		: public basic_ostream<charT,traits>
+	{
+	public:
+		typedef charT char_type;
+		typedef typename traits::int_type int_type;
+		typedef typename traits::pos_type pos_type;
+		typedef typename traits::off_type off_type;
+
+		_UCXXEXPORT basic_ofstream() : basic_ios<charT, traits>(&sb), basic_ostream<charT,traits>(&sb){
+
+		}
+
+		virtual _UCXXEXPORT ~basic_ofstream();
+
+		explicit _UCXXEXPORT basic_ofstream(const char* s, ios_base::openmode mode = ios_base::out | ios_base::trunc) :
+			basic_ios<charT, traits>(&sb), basic_ostream<charT,traits>(&sb)
+		{
+			if(sb.open(s, mode | ios_base::out ) == 0){
+				basic_ios<charT,traits>::setstate(ios_base::failbit);
+			}
+		}
+
+		_UCXXEXPORT basic_filebuf<charT,traits>* rdbuf() const{
+			return (basic_filebuf<charT,traits>*)&sb;
+		}
+
+		_UCXXEXPORT bool is_open() const{
+			return sb.is_open();
+		}
+		_UCXXEXPORT void open(const char* s, ios_base::openmode mode = ios_base::out | ios_base::trunc){
+			if(sb.open(s, mode) == 0){
+				basic_ios<charT,traits>::setstate(ios_base::failbit);
+			}
+		}
+		_UCXXEXPORT void close(){
+			sb.close();
+		}
+	private:
+		basic_filebuf<charT,traits> sb;
+	};
+
+	template <class charT, class traits> _UCXXEXPORT basic_ofstream<charT, traits>::~basic_ofstream(){
+		basic_ostream<charT, traits>::flush();
+	}
+
+
+	template <class charT, class traits> class _UCXXEXPORT basic_fstream
+		: public basic_iostream<charT,traits>
+	{
+	public:
+		typedef charT char_type;
+		typedef typename traits::int_type ins_type;
+		typedef typename traits::pos_type pos_type;
+		typedef typename traits::off_type off_type;
+
+		_UCXXEXPORT basic_fstream(): basic_ios<charT, traits>(&sb), basic_iostream<charT,traits>(&sb){ }
+
+		explicit _UCXXEXPORT basic_fstream(const char* s, ios_base::openmode mode = ios_base::in|ios_base::out):
+			basic_ios<charT, traits>(&sb), basic_iostream<charT,traits>(&sb)
+		{
+			if(sb.open(s, mode) == 0){
+				basic_ios<charT,traits>::setstate(ios_base::failbit);
+			}
+		}
+
+		_UCXXEXPORT basic_filebuf<charT,traits>* rdbuf() const{
+			return (basic_filebuf<charT,traits>*)&sb;
+		}
+		_UCXXEXPORT bool is_open() const{
+			return sb.is_open();
+		}
+		_UCXXEXPORT void open(const char* s, ios_base::openmode mode = ios_base::in|ios_base::out){
+			if(sb.open(s, mode) == 0){
+				basic_ios<charT,traits>::setstate(ios_base::failbit);
+			}
+		}
+		_UCXXEXPORT void close(){
+			sb.close();
+		}
+	private:
+		basic_filebuf<charT,traits> sb;
+	};
+
+
+
+#ifdef __UCLIBCXX_EXPAND_FSTREAM_CHAR__
+#ifndef __UCLIBCXX_COMPILE_FSTREAM__
+
+#ifdef __UCLIBCXX_EXPAND_CONSTRUCTORS_DESTRUCTORS__
+
+	template <> _UCXXEXPORT basic_ofstream<char, char_traits<char> >::basic_ofstream();
+	template <> _UCXXEXPORT basic_ofstream<char, char_traits<char> >::basic_ofstream(const char* s, ios_base::openmode mode);
+	template <> _UCXXEXPORT basic_ofstream<char, char_traits<char> >::~basic_ofstream();
+
+	template <> _UCXXEXPORT basic_ifstream<char, char_traits<char> >::basic_ifstream();
+	template <> _UCXXEXPORT basic_ifstream<char, char_traits<char> >::basic_ifstream(const char* s, ios_base::openmode mode);
+	template <> _UCXXEXPORT basic_ifstream<char, char_traits<char> >::~basic_ifstream();
+
+#endif // __UCLIBCXX_EXPAND_CONSTRUCTORS_DESTRUCTORS__
+
+#endif
+#endif
+
+
+
+}
+
+#pragma GCC visibility pop
+
+#endif
+

misc/uClibc++/include/cxx/func_exception

@@ -0,0 +1,41 @@
+/*	Copyright (C) 2004 Garrett A. Kajmowicz
+
+	This file is part of the uClibc++ Library.
+
+	This library is free software; you can redistribute it and/or
+	modify it under the terms of the GNU Lesser General Public
+	License as published by the Free Software Foundation; either
+	version 2.1 of the License, or (at your option) any later version.
+
+	This library is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+	Lesser General Public License for more details.
+
+	You should have received a copy of the GNU Lesser General Public
+	License along with this library; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+#include <basic_definitions>
+#include <exception>
+
+
+#ifndef HEADER_IMPLEMENTATION_FUNC_EXCEPTION
+#define HEADER_IMPLEMENTATION_FUNC_EXCEPTION
+
+#pragma GCC visibility push(default)
+
+namespace std{
+
+	_UCXXEXPORT void __throw_bad_alloc();
+	_UCXXEXPORT void __throw_out_of_range(const char * message = 0);
+	_UCXXEXPORT void __throw_overflow_error(const char * message = 0);
+	_UCXXEXPORT void __throw_length_error(const char * message = 0);
+	_UCXXEXPORT void __throw_invalid_argument(const char * message = 0);
+}
+
+#pragma GCC visibility pop
+
+#endif
+

misc/uClibc++/include/cxx/functional

@@ -0,0 +1,439 @@
+/*	Copyright (C) 2004 Garrett A. Kajmowicz
+	This file is part of the uClibc++ Library.
+	This library is free software; you can redistribute it and/or
+	modify it under the terms of the GNU Lesser General Public
+	License as published by the Free Software Foundation; either
+	version 2.1 of the License, or (at your option) any later version.
+
+	This library is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+	Lesser General Public License for more details.
+
+	You should have received a copy of the GNU Lesser General Public
+	License along with this library; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+
+#ifndef __STD_HEADER_FUNCTIONAL
+#define __STD_HEADER_FUNCTIONAL 1
+
+#include <basic_definitions>
+
+#pragma GCC visibility push(default)
+
+namespace std{
+
+	template <class Arg, class Result> struct unary_function;
+	template <class Arg1, class Arg2, class Result> struct binary_function;
+
+	template <class T> struct plus;
+	template <class T> struct minus;
+	template <class T> struct multiplies;
+	template <class T> struct divides;
+	template <class T> struct modulus;
+	template <class T> struct negate;
+
+	template <class T> struct equal_to;
+	template <class T> struct not_equal_to;
+	template <class T> struct greater;
+	template <class T> struct less;
+	template <class T> struct greater_equal;
+	template <class T> struct less_equal;
+
+	template <class T> struct logical_and;
+	template <class T> struct logical_or;
+	template <class T> struct logical_not;
+
+	template <class Predicate> struct unary_negate;
+	template <class Predicate> unary_negate<Predicate>  not1(const Predicate&);
+	template <class Predicate> struct binary_negate;
+	template <class Predicate> binary_negate<Predicate> not2(const Predicate&);
+
+
+	template <class Operation> class binder1st;
+	template <class Operation, class T> binder1st<Operation> bind1st(const Operation&, const T&);
+	template <class Operation> class binder2nd;
+	template <class Operation, class T> binder2nd<Operation> bind2nd(const Operation&, const T&);
+
+	template <class Arg, class Result> class pointer_to_unary_function;
+	template <class Arg, class Result> pointer_to_unary_function<Arg,Result> ptr_fun(Result (*)(Arg));
+	template <class Arg1, class Arg2, class Result> class pointer_to_binary_function;
+	template <class Arg1, class Arg2, class Result>
+		pointer_to_binary_function<Arg1,Arg2,Result> ptr_fun(Result (*)(Arg1,Arg2));
+
+	template<class S, class T> class mem_fun_t;
+	template<class S, class T, class A> class mem_fun1_t;
+	template<class S, class T> class const_mem_fun_t;
+	template<class S, class T, class A> class const_mem_fun1_t;
+	template<class S, class T> mem_fun_t<S,T> mem_fun(S (T::*f)());
+	template<class S, class T, class A> mem_fun1_t<S,T,A> mem_fun(S (T::*f)(A));
+	template<class S, class T> class mem_fun_ref_t;
+	template<class S, class T, class A> class mem_fun1_ref_t;
+	template<class S, class T> mem_fun_ref_t<S,T> mem_fun_ref(S (T::*f)());
+	template<class S, class T, class A> mem_fun1_ref_t<S,T,A> mem_fun1_ref(S (T::*f)(A));
+
+	//Implementation
+
+	template <class Arg, class Result> struct _UCXXEXPORT unary_function{
+		typedef Arg argument_type;
+		typedef Result result_type;
+	};
+
+
+	template <class Arg1, class Arg2, class Result> struct _UCXXEXPORT binary_function{
+		typedef Arg1   first_argument_type;
+		typedef Arg2   second_argument_type;
+		typedef Result result_type;
+	};
+
+	template <class T> struct _UCXXEXPORT plus : binary_function<T,T,T>{
+		T operator()(const T& x, const T& y) const{
+			return x + y;
+		}
+	};
+
+	template <class T> struct _UCXXEXPORT minus : binary_function<T,T,T>{
+		T operator()(const T& x, const T& y) const{
+			return x - y;
+		}
+	};
+
+	template <class T> struct _UCXXEXPORT multiplies : binary_function<T,T,T>{
+		T operator()(const T& x, const T& y) const{
+			return x * y;
+		}
+	};
+
+	template <class T> struct _UCXXEXPORT divides : binary_function<T,T,T>{
+		T operator()(const T& x, const T& y) const{
+			return x / y;
+		}
+	};
+
+	template <class T> struct _UCXXEXPORT modulus : binary_function<T,T,T>{
+		T operator()(const T& x, const T& y) const{
+			return x % y;
+		}
+	};
+
+	template <class T> struct _UCXXEXPORT negate : unary_function<T,T>{
+		T operator()(const T& x) const{
+			return -x;
+		}
+	};
+
+	template <class T> struct _UCXXEXPORT equal_to : binary_function<T,T,bool>{
+		bool operator()(const T& x, const T& y) const{
+			return (x == y);
+		}
+	};
+
+	template <class T> struct _UCXXEXPORT not_equal_to : binary_function<T,T,bool>{
+		bool operator()(const T& x, const T& y) const{
+			return (x != y);
+		}
+	};
+
+	template <class T> struct _UCXXEXPORT greater : binary_function<T,T,bool>{
+		bool operator()(const T& x, const T& y) const{
+			return (x > y);
+		}
+	};
+
+	template <class T> struct _UCXXEXPORT less : binary_function<T,T,bool>{
+		bool operator()(const T& x, const T& y) const{
+			return (x < y);
+		}
+	};
+
+	template <class T> struct _UCXXEXPORT greater_equal : binary_function<T,T,bool>{
+		bool operator()(const T& x, const T& y) const{
+			return (x >= y);
+		}
+	};
+
+	template <class T> struct _UCXXEXPORT less_equal : binary_function<T,T,bool>{
+		bool operator()(const T& x, const T& y) const{
+			return (x <= y);
+		}
+	};
+
+	template <class T> struct _UCXXEXPORT logical_and : binary_function<T,T,bool> {
+		bool operator()(const T& x, const T& y) const{
+			return (x && y);
+		}
+	};
+
+	template <class T> struct _UCXXEXPORT logical_or : binary_function<T,T,bool> {
+		bool operator()(const T& x, const T& y) const{
+			return (x || y);
+		}
+	};
+
+	template <class T> struct _UCXXEXPORT logical_not : unary_function<T,bool> {
+		bool operator()(const T& x) const{
+			return !x;
+		}
+	};
+
+	template <class Predicate> class _UCXXEXPORT unary_negate
+		: public unary_function<typename Predicate::argument_type,bool>
+	{
+	public:
+		explicit unary_negate(const Predicate& pred) : p(pred) {  }
+		bool operator()(const typename Predicate::argument_type& x) const{
+			return !p(x);
+		}
+	private:
+		Predicate p;
+	};
+
+
+	template <class Predicate> _UCXXEXPORT unary_negate<Predicate> not1(const Predicate& pred){
+		return unary_negate<Predicate>(pred);
+	}
+
+
+	template <class Predicate> class _UCXXEXPORT binary_negate : public
+		binary_function<typename Predicate::first_argument_type,
+			typename Predicate::second_argument_type, bool>
+	{
+	public:
+		explicit binary_negate(const Predicate& pred) : p(pred) {  }
+		bool operator()(const typename Predicate::first_argument_type& x,
+			const typename Predicate::second_argument_type& y) const
+		{
+			return !p(x, y);
+		}
+	private:
+		Predicate p;
+	};
+
+
+	template <class Predicate> _UCXXEXPORT binary_negate<Predicate> not2(const Predicate& pred){
+		return binary_negate<Predicate>(pred);
+	}
+
+
+	template <class Operation> class _UCXXEXPORT binder1st
+		: public unary_function<typename Operation::second_argument_type,
+			typename Operation::result_type>
+	{
+	protected:
+		Operation                      op;
+		typename Operation::first_argument_type value;
+	public:
+		binder1st(const Operation& x, const typename Operation::first_argument_type& y) : op(x), value(y){  }
+		typename Operation::result_type operator()(const typename Operation::second_argument_type& x) const{
+			return op(value,x);
+		}
+	};
+
+
+	template <class Operation, class T> _UCXXEXPORT binder1st<Operation> bind1st(const Operation& op, const T& x){
+		return binder1st<Operation>(op, typename Operation::first_argument_type(x));
+	}
+
+
+	template <class Operation> class _UCXXEXPORT binder2nd
+		: public unary_function<typename Operation::first_argument_type,
+			typename Operation::result_type>
+	{
+	protected:
+		Operation                       op;
+		typename Operation::second_argument_type value;
+	public:
+		binder2nd(const Operation& x, const typename Operation::second_argument_type& y) : op(x), value(y) {  }
+		typename Operation::result_type operator()(const typename Operation::first_argument_type& x) const{
+			return op(x,value);
+		}
+	};
+
+
+	template <class Operation, class T> _UCXXEXPORT
+		binder2nd<Operation> bind2nd(const Operation& op, const T& x)
+	{
+		return binder2nd<Operation>(op, typename Operation::second_argument_type(x));
+	}
+
+
+	template <class Arg, class Result> class _UCXXEXPORT
+		pointer_to_unary_function : public unary_function<Arg, Result>
+	{
+	protected:
+		Result (*func)(Arg);
+	public:
+		explicit pointer_to_unary_function(Result (*f)(Arg)) : func(f) {  }
+		Result operator()(Arg x) const{
+			return func(x);
+		}
+	};
+
+
+	template <class Arg, class Result> _UCXXEXPORT pointer_to_unary_function<Arg, Result> ptr_fun(Result (*f)(Arg)){
+		return pointer_to_unary_function<Arg, Result>(f);
+	}
+
+
+	template <class Arg1, class Arg2, class Result>	class _UCXXEXPORT
+		pointer_to_binary_function : public binary_function<Arg1,Arg2,Result>
+	{
+	protected:
+		Result (*func)(Arg1, Arg2);
+	public:
+		explicit pointer_to_binary_function(Result (*f)(Arg1, Arg2)) : func(f) {  }
+		Result operator()(Arg1 x, Arg2 y) const{
+			return func(x, y);
+		}
+	};
+
+	template <class Arg1, class Arg2, class Result> _UCXXEXPORT
+		pointer_to_binary_function<Arg1,Arg2,Result> ptr_fun(Result (*f)(Arg1, Arg2))
+	{
+		return pointer_to_binary_function<Arg1,Arg2,Result>(f);
+	}
+
+
+	template <class S, class T> class _UCXXEXPORT mem_fun_t
+		: public unary_function<T*, S>
+	{
+	public:
+		explicit mem_fun_t(S (T::*p)()) : m(p) {  }
+		S operator()(T* p) const { return (p->*m)(); }
+	private:
+		S (T::*m)();
+	};
+
+
+	template <class S, class T, class A> class _UCXXEXPORT mem_fun1_t
+		: public binary_function<T*, A, S>
+	{
+	public:
+		explicit mem_fun1_t(S (T::*p)(A)) : m(p) {  }
+		S operator()(T* p, A x) const { return (p->*m)(x); }
+	private:
+		S (T::*m)(A);
+	};
+
+
+	template <class S, class T> class _UCXXEXPORT const_mem_fun_t
+		: public unary_function<const T*, S>
+	{
+	public:
+		explicit const_mem_fun_t(S (T::*p)() const) : m(p) {  }
+		S operator()(const T* p) const { return (p->*m)(); }
+	private:
+		S (T::*m)() const;
+	};
+
+
+	template <class S, class T, class A> class _UCXXEXPORT const_mem_fun1_t
+		: public binary_function<T*, A, S>
+	{
+	public:
+		explicit const_mem_fun1_t(S (T::*p)(A) const) : m(p) {  }
+		S operator()(const T* p, A x) const { return (p->*m)(x); }
+	private:
+		S (T::*m)(A) const;
+	};
+
+
+	template<class S, class T> _UCXXEXPORT mem_fun_t<S,T> mem_fun(S (T::*f)()){
+		return mem_fun_t<S, T>(f);
+	}
+
+	template<class S, class T> _UCXXEXPORT const_mem_fun_t<S,T> mem_fun(S (T::*f)() const){
+		return const_mem_fun_t<S, T>(f);
+	}
+
+	template<class S, class T, class A> _UCXXEXPORT mem_fun1_t<S,T,A> mem_fun(S (T::*f)(A)){
+		return mem_fun1_t<S, T, A>(f);
+	}
+
+	template<class S, class T, class A> _UCXXEXPORT const_mem_fun1_t<S,T,A> mem_fun(S (T::*f)(A) const){
+		return const_mem_fun1_t<S, T, A>(f);
+	}
+
+	template <class S, class T> class _UCXXEXPORT mem_fun_ref_t
+		: public unary_function<T, S>
+	{
+	public:
+		explicit mem_fun_ref_t(S (T::*p)()) : mf(p) {  }
+		S operator()(T& p) { return (p.*mf)(); }
+	private:
+		S (T::*mf)();
+	};
+
+	template <class S, class T, class A> class _UCXXEXPORT mem_fun1_ref_t
+		: public binary_function<T, A, S>
+	{
+	public:
+		explicit mem_fun1_ref_t(S (T::*p)(A)) : mf(p) {  }
+		S operator()(T& p, A x) { return (p.*mf)(x); }
+	private:
+		S (T::*mf)(A);
+	};
+
+	template<class S, class T> _UCXXEXPORT mem_fun_ref_t<S,T> mem_fun_ref(S (T::*f)()){
+		return mem_fun_ref_t<S,T>(f);
+	}
+
+	template<class S, class T, class A> _UCXXEXPORT mem_fun1_ref_t<S,T,A> mem_fun1_ref(S (T::*f)(A)){
+		return mem_fun1_ref_t<S,T,A>(f);
+	}
+
+
+}
+
+
+//These are SGI extensions which are checked for by some conformance checks.  They
+// are *NOT* part of the C++ standard, however
+
+template <class Op1, class Op2> class _UCXXEXPORT unary_compose :
+	public std::unary_function<typename Op2::argument_type,
+		typename Op1::result_type>
+{
+protected:
+	Op1 mf1;
+	Op2 mf2;
+public:
+	unary_compose(const Op1& x, const Op2& y) : mf1(x), mf2(y) {  }
+	typename Op1::result_type operator()(const typename Op2::argument_type& x) const {
+		return mf1(mf2(x));
+	}
+};
+
+template <class Op1, class Op2> _UCXXEXPORT
+inline unary_compose<Op1, Op2>
+compose1(const Op1& fn1, const Op2& fn2){
+	return unary_compose<Op1, Op2>(fn1, fn2);
+}
+
+template <class Op1, class Op2, class Op3> class _UCXXEXPORT binary_compose :
+	public std::unary_function<typename Op2::argument_type, typename Op1::result_type>
+{
+protected:
+	Op1 mf1;
+	Op2 mf2;
+	Op3 mf3;
+public:
+	binary_compose(const Op1 & x, const Op2 & y, const Op3 & z)
+		: mf1(x), mf2(y), mf3(z){  }
+	typename Op1::result_type operator()(const typename Op2::argument_type & x) const {
+		return mf1(mf2(x), mf3(x));
+	}
+};
+
+template <class Op1, class Op2, class Op3> inline _UCXXEXPORT binary_compose<Op1, Op2, Op3>
+compose2(const Op1 & fn1, const Op2 & fn2, const Op3 & fn3){
+	return binary_compose<Op1, Op2, Op3>(fn1, fn2, fn3);
+}
+
+#pragma GCC visibility pop
+
+#endif
+
+
+

misc/uClibc++/include/cxx/iomanip

@@ -0,0 +1,170 @@
+/*	Copyright (C) 2005 Garrett A. Kajmowicz
+
+	This file is part of the uClibc++ Library.
+
+	This library is free software; you can redistribute it and/or
+	modify it under the terms of the GNU Lesser General Public
+	License as published by the Free Software Foundation; either
+	version 2.1 of the License, or (at your option) any later version.
+
+	This library is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+	Lesser General Public License for more details.
+
+	You should have received a copy of the GNU Lesser General Public
+	License along with this library; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+#include <exception>
+#include <ios>
+
+#ifndef __STD_IOMANIP
+#define __STD_IOMANIP 1
+
+#pragma GCC visibility push(default)
+
+namespace std{
+
+// These are the helper classes which we are going to be using to
+// hold the required data
+
+class _UCXXEXPORT __resetiosflags{
+public:
+	ios_base::fmtflags m;
+	_UCXXEXPORT __resetiosflags(ios_base::fmtflags mask) : m(mask){ }
+};
+
+class _UCXXEXPORT __setiosflags{
+public:
+	ios_base::fmtflags m;
+	_UCXXEXPORT __setiosflags(ios_base::fmtflags mask) : m(mask){ }
+};
+
+class _UCXXEXPORT __setbase{
+public:
+	int base;
+	_UCXXEXPORT __setbase(int b) : base(b){ }
+};
+
+class _UCXXEXPORT __setfill{
+public:
+	int character;
+	_UCXXEXPORT __setfill(int c): character(c){  }
+};
+
+class _UCXXEXPORT __setprecision{
+public:
+	int digits;
+	_UCXXEXPORT __setprecision(int n): digits(n) {  }
+};
+
+class _UCXXEXPORT __setw{
+public:
+	int width;
+	_UCXXEXPORT __setw(int n): width(n) {  }
+};
+
+
+//Actual manipulator functions
+
+inline __resetiosflags resetiosflags(ios_base::fmtflags mask){
+	return __resetiosflags(mask);
+}
+
+inline __setiosflags setiosflags(ios_base::fmtflags mask){
+	return __setiosflags(mask);
+}
+
+inline __setbase setbase(int b){
+	return __setbase(b);
+}
+
+inline __setfill setfill(int c){
+	return __setfill(c);
+}
+
+inline __setprecision setprecision(int n){
+	return __setprecision(n);
+}
+
+inline __setw setw(int n){
+	return __setw(n);
+}
+
+
+//How to handle interaction with [i|o]stream classes
+
+template<class Ch, class Tr> _UCXXEXPORT basic_ostream<Ch, Tr>&
+	operator<<(basic_ostream<Ch, Tr>& os, const __resetiosflags s)
+{
+	os.setf(ios_base::fmtflags(0),s.m);
+	return os;
+}
+
+template<class Ch, class Tr> _UCXXEXPORT basic_istream<Ch, Tr>&
+	operator>>(basic_istream<Ch, Tr>& is, const __resetiosflags s)
+{
+	is.setf(ios_base::fmtflags(0),s.m);
+	return is;
+}
+
+template<class Ch, class Tr> _UCXXEXPORT basic_ostream<Ch, Tr>&
+	operator<<(basic_ostream<Ch, Tr>& os, const __setiosflags s)
+{
+	os.setf(s.m);
+	return os;
+}
+
+template<class Ch, class Tr> _UCXXEXPORT basic_ostream<Ch, Tr>&
+	operator<<(basic_ostream<Ch, Tr>& os, const __setbase s)
+{
+	ios_base::fmtflags f(0);
+	switch(s.base){
+		case 8:
+			f = ios_base::oct;
+			break;
+		case 10:
+			f = ios_base::dec;
+			break;
+		case 16:
+			f = ios_base::hex;
+			break;
+		default:
+			break;
+
+	}
+	os.setf(f, ios_base::basefield);
+	return os;
+}
+
+template<class Ch, class Tr> _UCXXEXPORT basic_ostream<Ch, Tr>&
+	operator<<(basic_ostream<Ch, Tr>& os, const __setfill s)
+{
+	os.fill(s.character);
+	return os;
+}
+
+template<class Ch, class Tr> _UCXXEXPORT basic_ostream<Ch, Tr>&
+	operator<<(basic_ostream<Ch, Tr>& os, const __setprecision s)
+{
+	os.precision(s.digits);
+	return os;
+}
+
+template<class Ch, class Tr> _UCXXEXPORT basic_ostream<Ch, Tr>&
+	operator<<(basic_ostream<Ch, Tr>& os, const __setw s)
+{
+	os.width(s.width);
+	return os;
+}
+
+
+
+}
+
+#pragma GCC visibility pop
+
+#endif
+

misc/uClibc++/include/cxx/ios

@@ -0,0 +1,500 @@
+/*	Copyright (C) 2004 Garrett A. Kajmowicz
+
+	This file is part of the uClibc++ Library.
+
+	This library is free software; you can redistribute it and/or
+	modify it under the terms of the GNU Lesser General Public
+	License as published by the Free Software Foundation; either
+	version 2.1 of the License, or (at your option) any later version.
+
+	This library is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+	Lesser General Public License for more details.
+
+	You should have received a copy of the GNU Lesser General Public
+	License along with this library; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+#include <basic_definitions>
+#include <cstddef>
+#include <locale>
+#include <iosfwd>
+
+#ifndef __HEADER_STD_IOS
+#define __HEADER_STD_IOS 1
+
+#pragma GCC visibility push(default)
+
+namespace std{
+	typedef signed long int streamoff;
+
+	template <class stateT> class fpos;
+
+	class _UCXXEXPORT ios_base {
+	public:
+		class failure;
+#ifdef __UCLIBCXX_EXCEPTION_SUPPORT__
+		class failure : public exception {
+		public:
+			explicit failure(const std::string&) { }
+			explicit failure() { }
+			virtual const char* what() const throw() {
+				return "std::ios_base failure exception";
+			}
+		};
+#endif
+#ifdef __UCLIBCXX_SUPPORT_CDIR__
+		class _UCXXLOCAL Init{
+		public:
+			_UCXXEXPORT Init();
+			_UCXXEXPORT ~Init();
+		private:
+			static int init_cnt;
+		};
+#endif
+
+	public:
+
+		typedef unsigned short int fmtflags;
+
+		static const fmtflags skipws 		= 0x0001;
+
+		static const fmtflags left		= 0x0002;
+		static const fmtflags right		= 0x0004;
+		static const fmtflags internal		= 0x0008;
+
+		static const fmtflags boolalpha		= 0x0010;
+
+		static const fmtflags dec	 	= 0x0020;
+		static const fmtflags oct 		= 0x0040;
+		static const fmtflags hex 		= 0x0080;
+
+		static const fmtflags scientific	= 0x0100;
+		static const fmtflags fixed 		= 0x0200;
+
+		static const fmtflags showbase 		= 0x0400;
+		static const fmtflags showpoint		= 0x0800;
+		static const fmtflags showpos		= 0x1000;
+		static const fmtflags uppercase		= 0x2000;
+
+		static const fmtflags adjustfield	= left | right | internal;
+		static const fmtflags basefield		= dec | oct | hex;
+		static const fmtflags floatfield	= fixed | scientific;
+
+		static const fmtflags unitbuf		= 0x4000;
+
+		typedef unsigned char iostate;
+		static const iostate goodbit		= 0x00;
+		static const iostate badbit		= 0x01;
+		static const iostate eofbit		= 0x02;
+		static const iostate failbit 		= 0x04;
+
+		typedef unsigned char openmode;
+		static const openmode app		= 0x01;
+		static const openmode ate		= 0x02;
+		static const openmode binary		= 0x04;
+		static const openmode in		= 0x08;
+		static const openmode out		= 0x10;
+		static const openmode trunc		= 0x20;
+
+		typedef unsigned char seekdir;
+		static const seekdir beg		= 0x01;
+		static const seekdir cur		= 0x02;
+		static const seekdir end		= 0x04;
+
+		_UCXXEXPORT fmtflags flags() const{
+			return mformat;
+		}
+		_UCXXEXPORT fmtflags flags(fmtflags fmtfl);
+
+		fmtflags setf(fmtflags fmtfl);
+		fmtflags setf(fmtflags fmtfl, fmtflags mask );
+
+		_UCXXEXPORT void unsetf(fmtflags mask){
+			mformat&= ~mask;
+		}
+
+		_UCXXEXPORT streamsize precision() const{
+			return mprecision;
+		}
+
+		_UCXXEXPORT streamsize precision(streamsize prec);
+
+		_UCXXEXPORT streamsize width() const{
+			return mwidth;
+		}
+
+		_UCXXEXPORT streamsize width(streamsize wide);
+
+		_UCXXEXPORT locale imbue(const locale& loc);
+
+		_UCXXEXPORT locale getloc() const{
+			return mLocale;
+		}
+
+//		FIXME - These need to be implemented
+//		static int xalloc();
+//		long&  iword(int index);
+//		void*& pword(int index);
+
+		_UCXXEXPORT ~ios_base() { }
+
+		enum event { erase_event, imbue_event, copyfmt_event };
+
+		typedef void (*event_callback)(event, ios_base&, int index);
+//		void register_callback(event_call_back fn, int index);
+
+		//We are going to wrap stdio so we don't need implementation of the following:
+		inline static bool sync_with_stdio(bool = true) { return true; }
+
+	protected:
+		_UCXXEXPORT ios_base() : mLocale(), mformat(dec | skipws ), mstate(goodbit),
+			mmode(), mdir(), mprecision(6), mwidth(0)
+#ifdef __UCLIBCXX_SUPPORT_CDIR__
+			,mInit()
+#endif
+		{
+
+		}
+		locale mLocale;
+		fmtflags mformat;
+		iostate mstate;
+		openmode mmode;
+		seekdir mdir;
+		streamsize mprecision;
+		streamsize mwidth;
+#ifdef __UCLIBCXX_SUPPORT_CDIR__
+		Init mInit;
+#endif
+	};
+
+
+	//ios_base manipulators
+
+
+	inline ios_base& boolalpha  (ios_base& str){
+		str.setf(ios_base::boolalpha);
+		return str;
+	}
+	inline ios_base& noboolalpha(ios_base& str){
+		str.unsetf(ios_base::boolalpha);
+		return str;
+	}
+	inline ios_base& showbase   (ios_base& str){
+		str.setf(ios_base::showbase);
+		return str;
+	}
+	inline ios_base& noshowbase (ios_base& str){
+		str.unsetf(ios_base::showbase);
+		return str;
+	}
+	inline ios_base& showpoint  (ios_base& str){
+		str.setf(ios_base::showpoint);
+		return str;
+	}
+	inline ios_base& noshowpoint(ios_base& str){
+		str.unsetf(ios_base::showpoint);
+		return str;
+	}
+	inline ios_base& showpos    (ios_base& str){
+		str.setf(ios_base::showpos);
+		return str;
+	}
+	inline ios_base& noshowpos  (ios_base& str){
+		str.unsetf(ios_base::showpos);
+		return str;
+	}
+	inline ios_base& skipws     (ios_base& str){
+		str.setf(ios_base::skipws);
+		return str;
+	}
+	inline ios_base& noskipws   (ios_base& str){
+		str.unsetf(ios_base::skipws);
+		return str;
+	}
+	inline ios_base& uppercase  (ios_base& str){
+		str.setf(ios_base::uppercase);
+		return str;
+	}
+	inline ios_base& nouppercase(ios_base& str){
+		str.unsetf(ios_base::uppercase);
+		return str;
+	}
+
+	inline ios_base& unitbuf    (ios_base& str){
+		str.setf(ios_base::unitbuf);
+		return str;
+	}
+	inline ios_base& nounitbuf  (ios_base& str){
+		str.unsetf(ios_base::unitbuf);
+		return str;
+	}
+	inline ios_base& internal   (ios_base& str){
+		str.setf(ios_base::internal, ios_base::adjustfield);
+		return str;
+	}
+	inline ios_base& left       (ios_base& str){
+		str.setf(ios_base::left, ios_base::adjustfield);
+		return str;
+	}
+	inline ios_base& right      (ios_base& str){
+		str.setf(ios_base::right, ios_base::adjustfield);
+		return str;
+	}
+
+	inline ios_base& dec        (ios_base& str){
+		str.setf(ios_base::dec, ios_base::basefield);
+		return str;
+	}
+	inline ios_base& hex        (ios_base& str){
+		str.setf(ios_base::hex, ios_base::basefield);
+		return str;
+	}
+	inline ios_base& oct        (ios_base& str){
+		str.setf(ios_base::oct, ios_base::basefield);
+		return str;
+	}
+
+	inline ios_base& fixed      (ios_base& str){
+		str.setf(ios_base::fixed, ios_base::floatfield);
+		return str;
+	}
+	inline ios_base& scientific (ios_base& str){
+		str.setf(ios_base::scientific, ios_base::floatfield);
+		return str;
+	}
+
+
+	//basic_ios class definition
+
+
+	template <class charT, class traits > class _UCXXEXPORT basic_ios
+		: public ios_base
+	{
+	public:
+	// Types:
+		typedef charT char_type;
+		typedef typename traits::int_type int_type;
+		typedef typename traits::pos_type pos_type;
+		typedef typename traits::off_type off_type;
+		typedef traits traits_type;
+
+		_UCXXEXPORT operator void*() const{
+			if(fail() ){
+				return 0;
+			}
+			return (void *)(1);	//Must return a non-NULL pointer (though it can be *any* pointer)
+		}
+
+		_UCXXEXPORT bool operator!() const{
+			return fail();
+		}
+		_UCXXEXPORT iostate rdstate() const{
+			return mstate;
+		}
+		_UCXXEXPORT void clear(iostate state = goodbit){
+			if(rdbuf()!=0){
+				mstate = state;
+			}else{
+				mstate = state|ios_base::badbit;
+			}
+		}
+		_UCXXEXPORT void setstate(iostate state) {
+			clear(rdstate()  | state);
+#ifdef __UCLIBCXX_EXCEPTION_SUPPORT__
+			if(rdstate() & throw_mask){
+				throw failure();
+			}
+#endif
+		}
+
+		_UCXXEXPORT bool good() const{
+			return (rdstate() == 0);
+		}
+		_UCXXEXPORT bool eof()  const{
+			if(rdstate() & eofbit){
+				return true;
+			}
+			return false;
+		}
+		_UCXXEXPORT bool fail() const{
+			if( mstate & (failbit | badbit) ){
+				return true;
+			}
+			return false;
+		}
+
+		_UCXXEXPORT bool bad()  const{
+			if(mstate & badbit){
+				return true;
+			}
+			return false;
+		}
+
+		_UCXXEXPORT iostate exceptions() const{
+			return throw_mask;
+		}
+		_UCXXEXPORT void exceptions(iostate except){
+			throw_mask = except;
+		}
+
+		explicit _UCXXEXPORT basic_ios(basic_streambuf<charT,traits>* sb) : fill_char(' '), mtied(0), mstreambuf(0){
+			init(sb);
+		}
+
+		basic_ios() : mtied(0), mstreambuf(0){ }
+
+		virtual _UCXXEXPORT ~basic_ios(){
+		}
+
+		_UCXXEXPORT basic_ostream<charT,traits>* tie() const{
+			return mtied;
+		}
+		_UCXXEXPORT basic_ostream<charT,traits>* tie(basic_ostream<charT,traits>* tiestr){
+			basic_ostream<charT,traits>* retval= mtied;
+			mtied = tiestr;
+			return retval;
+		}
+		_UCXXEXPORT basic_streambuf<charT,traits>* rdbuf() const{
+			return mstreambuf;
+		}
+		_UCXXEXPORT basic_streambuf<charT,traits>* rdbuf(basic_streambuf<charT,traits>* sb){
+			basic_streambuf<charT,traits>* retval = mstreambuf;
+			mstreambuf = sb;
+			return retval;
+		}
+		_UCXXEXPORT basic_ios& copyfmt(const basic_ios& rhs);
+		_UCXXEXPORT char_type fill() const{
+			return fill_char;
+		}
+		_UCXXEXPORT char_type fill(char_type ch){
+			char_type temp = fill_char;
+			fill_char = ch;
+			return temp;
+		}
+
+		_UCXXEXPORT locale imbue(const locale& loc){
+			return ios_base::imbue(loc);
+		}
+		_UCXXEXPORT char narrow(char_type c, char dfault) const;
+		_UCXXEXPORT char_type widen(char c) const;
+
+	protected:
+		char_type fill_char;
+		basic_ostream<charT,traits>* mtied;
+		basic_streambuf<charT,traits>* mstreambuf;
+		iostate throw_mask;
+		_UCXXEXPORT basic_ios(const basic_ios<charT,traits> &){ }
+		_UCXXEXPORT basic_ios<charT,traits> & operator=(const basic_ios<charT,traits> &){ return *this; }
+		_UCXXEXPORT void init(basic_streambuf<charT,traits>* sb){
+			ios_base::mformat = skipws|dec;
+			mstreambuf = sb;
+			mstate = goodbit;
+			throw_mask = goodbit;
+		}
+	};
+
+#ifdef __UCLIBCXX_EXPAND_IOS_CHAR__
+#ifndef __UCLIBCXX_COMPILE_IOS__
+
+	template <> _UCXXEXPORT void basic_ios<char, char_traits<char> >::clear(iostate state);
+	template <> _UCXXEXPORT void basic_ios<char, char_traits<char> >::setstate(iostate state);
+
+#endif
+#endif
+
+
+	template <class charT, class traits>
+		inline char basic_ios<charT, traits>::narrow(char_type c, char dfault) const
+	{
+		return dfault;
+	}
+
+	template <>
+		inline char basic_ios<char, char_traits<char> >::narrow(char_type c, char) const
+	{
+		return c;
+	}
+
+#ifdef __UCLIBCXX_HAS_WCHAR__
+
+	template <>
+		inline char basic_ios<wchar_t, char_traits<wchar_t> >::narrow(char_type c, char dfault) const
+	{
+		char retval = wctob (c);
+		if(retval == EOF){
+			retval = dfault;
+		}
+		return retval;
+	}
+
+#endif	//__UCLIBCXX_HAS_WCHAR__
+
+	template <class charT, class traits>
+		inline typename basic_ios<charT, traits>::char_type
+		basic_ios<charT, traits>::widen(char c) const
+	{
+		return c;
+	}
+
+	template <>
+		inline basic_ios<char, char_traits<char> >::char_type
+		basic_ios<char, char_traits<char> >::widen(char c) const
+	{
+		return c;
+	}
+
+#ifdef __UCLIBCXX_HAS_WCHAR__
+
+	template <>
+		inline basic_ios<wchar_t, char_traits<wchar_t> >::char_type
+		basic_ios<wchar_t, char_traits<wchar_t> >::widen(char c) const
+	{
+		return btowc(c);
+	}
+
+#endif //__UCLIBCXX_HAS_WCHAR__
+
+
+	template <class stateT> class _UCXXEXPORT fpos{
+	public:
+		_UCXXEXPORT fpos(stateT s){
+			st = s;
+		}
+		_UCXXEXPORT stateT state() const{
+			return st;
+		}
+		_UCXXEXPORT void state(stateT s){
+			st = s;
+		}
+		_UCXXEXPORT bool operator==(const fpos &rhs){
+			return st == rhs.st;
+		}
+		_UCXXEXPORT bool operator!=(const fpos &rhs){
+			return st != rhs.st;
+		}
+		_UCXXEXPORT fpos & operator+(const streamoff & o){
+			st += o;
+			return *this;
+		}
+		_UCXXEXPORT fpos & operator-(const streamoff & o){
+			st -= o;
+			return *this;
+		}
+		_UCXXEXPORT streamoff operator-(const fpos & rhs){
+			return st - rhs.st;
+		}
+
+	private:
+		stateT st;
+	};
+
+
+}
+
+#pragma GCC visibility pop
+
+#endif
+

misc/uClibc++/include/cxx/iosfwd

@@ -0,0 +1,114 @@
+/*	Copyright (C) 2004 Garrett A. Kajmowicz
+
+	This file is part of the uClibc++ Library.
+
+	This library is free software; you can redistribute it and/or
+	modify it under the terms of the GNU Lesser General Public
+	License as published by the Free Software Foundation; either
+	version 2.1 of the License, or (at your option) any later version.
+
+	This library is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+	Lesser General Public License for more details.
+
+	You should have received a copy of the GNU Lesser General Public
+	License along with this library; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+#include <basic_definitions>
+#include <char_traits>
+#include <memory>
+
+
+#ifndef __HEADER_STD_IOSFWD
+#define __HEADER_STD_IOSFWD 1
+
+#pragma GCC visibility push(default)
+
+namespace std {
+	class ios_base;
+	template<> class char_traits<char>;
+
+#ifdef __UCLIBCXX_HAS_WCHAR__
+	template<> class char_traits<wchar_t>;
+#endif
+
+	template <class charT, class traits = char_traits<charT> > class basic_ios;
+
+	template <class charT, class traits = char_traits<charT> > class basic_streambuf;
+	template <class charT, class traits = char_traits<charT> > class basic_istream;
+	template <class charT, class traits = char_traits<charT> > class basic_ostream;
+	template <class charT, class traits = char_traits<charT> > class basic_iostream;
+
+	template <class charT, class traits = char_traits<charT>, 
+		class Allocator = allocator<charT> > class basic_stringbuf;
+
+	template <class charT, class traits = char_traits<charT>, 
+		class Allocator = allocator<charT> > class basic_istringstream;
+
+	template <class charT, class traits = char_traits<charT>,
+		class Allocator = allocator<charT> > class basic_ostringstream;
+
+	template <class charT, class traits = char_traits<charT>,
+		class Allocator = allocator<charT> > class basic_stringstream;
+
+	template <class charT, class traits = char_traits<charT> > class basic_filebuf;
+
+	template <class charT, class traits = char_traits<charT> > class basic_ifstream;
+
+	template <class charT, class traits = char_traits<charT> > class basic_ofstream;
+
+	template <class charT, class traits = char_traits<charT> > class basic_fstream;
+
+	template <class charT, class traits = char_traits<charT> > class basic_istreambuf_iterator;
+
+	template <class charT, class traits = char_traits<charT> > class basic_ostreambuf_iterator;
+
+	typedef basic_ios<char>       ios;
+#ifdef __UCLIBCXX_HAS_WCHAR__
+	typedef basic_ios<wchar_t>    wios;
+#endif
+
+	typedef basic_streambuf<char> streambuf;
+	typedef basic_istream<char>   istream;
+	typedef basic_ostream<char>   ostream;
+	typedef basic_iostream<char>  iostream;
+
+	typedef basic_stringbuf<char>     stringbuf;
+	typedef basic_istringstream<char> istringstream;
+	typedef basic_ostringstream<char> ostringstream;
+	typedef basic_stringstream<char>  stringstream;
+
+	typedef basic_filebuf<char>  filebuf;
+	typedef basic_ifstream<char> ifstream;
+	typedef basic_ofstream<char> ofstream;
+	typedef basic_fstream<char>  fstream;
+#ifdef __UCLIBCXX_HAS_WCHAR__
+	typedef basic_streambuf<wchar_t> wstreambuf;
+	typedef basic_istream<wchar_t>   wistream;
+	typedef basic_ostream<wchar_t>   wostream;
+	typedef basic_iostream<wchar_t>  wiostream;
+
+	typedef basic_stringbuf<wchar_t>     wstringbuf;
+	typedef basic_istringstream<wchar_t> wistringstream;
+	typedef basic_ostringstream<wchar_t> wostringstream;
+	typedef basic_stringstream<wchar_t>  wstringstream;
+
+	typedef basic_filebuf<wchar_t>  wfilebuf;
+	typedef basic_ifstream<wchar_t> wifstream;
+	typedef basic_ofstream<wchar_t> wofstream;
+	typedef basic_fstream<wchar_t>  wfstream;
+#endif
+	
+	template <class state> class fpos;
+	typedef fpos<char_traits<char>::state_type> streampos;
+#ifdef __UCLIBCXX_HAS_WCHAR__
+	typedef fpos<char_traits<wchar_t>::state_type> wstreampos;
+#endif
+}
+
+#pragma GCC visibility pop
+
+#endif

misc/uClibc++/include/cxx/iostream

@@ -0,0 +1,101 @@
+/*	Copyright (C) 2004 Garrett A. Kajmowicz
+
+	This file is part of the uClibc++ Library.
+
+	This library is free software; you can redistribute it and/or
+	modify it under the terms of the GNU Lesser General Public
+	License as published by the Free Software Foundation; either
+	version 2.1 of the License, or (at your option) any later version.
+
+	This library is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+	Lesser General Public License for more details.
+
+	You should have received a copy of the GNU Lesser General Public
+	License along with this library; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+#include <basic_definitions>
+
+#ifndef __HEADER_STD_IOSTREAM
+#define __HEADER_STD_IOSTREAM 1
+
+#include <iosfwd>
+#include <ios>
+#include <istream>
+#include <ostream>
+#include <fstream>
+#include <string_iostream>
+
+#pragma GCC visibility push(default)
+
+namespace std{
+#ifdef __UCLIBCXX_SUPPORT_CIN__
+	extern istream cin;
+#endif
+#ifdef __UCLIBCXX_SUPPORT_COUT__
+	extern ostream cout;
+#endif
+#ifdef __UCLIBCXX_SUPPORT_CERR__
+	extern ostream cerr;
+#endif
+#ifdef __UCLIBCXX_SUPPORT_CLOG__
+	extern ostream clog;
+#endif
+#ifdef __UCLIBCXX_SUPPORT_WCIN__
+	extern wistream wcin;
+#endif
+#ifdef __UCLIBCXX_SUPPORT_WCOUT__
+	extern wostream wcout;
+#endif
+#ifdef __UCLIBCXX_SUPPORT_WCERR__
+	extern wostream wcerr;
+#endif
+#ifdef __UCLIBCXX_SUPPORT_WCLOG__
+	extern wostream wclog;
+#endif
+
+
+	template <class charT, class traits> class _UCXXEXPORT basic_iostream :
+		public basic_istream<charT,traits>, public basic_ostream<charT,traits> 
+	{
+	public:
+		// constructor/destructor
+		explicit _UCXXEXPORT basic_iostream(basic_streambuf<charT,traits>* sb);
+		virtual _UCXXEXPORT ~basic_iostream();	//Below
+	};
+
+	template <class charT, class traits> _UCXXEXPORT 
+		basic_iostream<charT, traits>:: basic_iostream(basic_streambuf<charT,traits>* sb)
+		: basic_ios<charT, traits>(sb), basic_istream<charT,traits>(sb), basic_ostream<charT,traits>(sb)
+	{
+		return;
+	}
+
+
+	template <class charT, class traits> _UCXXEXPORT basic_iostream<charT, traits>::~basic_iostream(){
+		return;
+	}
+
+
+#ifdef __UCLIBCXX_EXPAND_OSTREAM_CHAR__
+#ifdef __UCLIBCXX_EXPAND_ISTREAM_CHAR__
+#ifndef __UCLIBCXX_COMPILE_IOSTREAM__
+
+	template <> _UCXXEXPORT basic_iostream<char, char_traits<char> >::
+		basic_iostream(basic_streambuf<char, char_traits<char> >* sb);
+	template <> _UCXXEXPORT basic_iostream<char, char_traits<char> >::~basic_iostream();
+
+#endif
+#endif
+#endif
+
+
+
+}
+
+#pragma GCC visibility pop
+
+#endif

misc/uClibc++/include/cxx/istream

@@ -0,0 +1,599 @@
+/*	Copyright (C) 2004 Garrett A. Kajmowicz
+
+	This file is part of the uClibc C++ Library.  This library is free
+	software; you can redistribute it and/or modify it under the
+	terms of the GNU General Public License as published by the
+	Free Software Foundation; either version 2, or (at your option)
+	any later version.
+
+	This library is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License along
+	with this library; see the file COPYING.  If not, write to the Free
+	Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+	USA.
+*/
+
+#include <ios>
+#include <cctype>
+#include <streambuf>
+#include <istream_helpers>
+#include <ostream>
+
+#ifndef __STD_HEADER_ISTREAM
+#define __STD_HEADER_ISTREAM 1
+
+#pragma GCC visibility push(default)
+
+namespace std{
+
+	typedef basic_istream<char> istream;
+
+#ifdef __UCLIBCXX_HAS_WCHAR__
+	typedef basic_istream<wchar_t> wistream;
+#endif
+
+	template <class charT, class traits> basic_istream<charT,traits>& ws(basic_istream<charT,traits>& is);
+
+	template <class charT, class traits> class _UCXXEXPORT basic_istream :
+		virtual public basic_ios<charT,traits>
+	{
+	public:
+
+		typedef charT                     char_type;
+		typedef typename traits::int_type int_type;
+		typedef typename traits::pos_type pos_type;
+		typedef typename traits::off_type off_type;
+		typedef basic_streambuf<charT,traits>  streambuf_type;
+		typedef traits                    traits_type;
+
+		explicit basic_istream(basic_streambuf<charT,traits>* sb)
+			: basic_ios<charT, traits>(sb), count_last_ufmt_input(0)
+		{
+			basic_ios<charT, traits>::init(sb);
+		}
+		virtual ~basic_istream() { }
+
+		class sentry;
+
+		basic_istream<charT,traits>& operator>>(basic_istream<charT,traits>& (*pf)(basic_istream<charT,traits>&));
+		basic_istream<charT,traits>& operator>>(basic_ios<charT,traits>& (*pf)(basic_ios<charT,traits>&));
+		basic_istream<charT,traits>& operator>>(ios_base& (*pf)(ios_base&));
+		basic_istream<charT,traits>& operator>>(bool& n);
+		basic_istream<charT,traits>& operator>>(short& n);
+		basic_istream<charT,traits>& operator>>(unsigned short& n);
+		basic_istream<charT,traits>& operator>>(int& n);
+		basic_istream<charT,traits>& operator>>(unsigned int& n);
+		basic_istream<charT,traits>& operator>>(long& n);
+		basic_istream<charT,traits>& operator>>(unsigned long& n);
+		basic_istream<charT,traits>& operator>>(void*& p);
+		basic_istream<charT,traits>& operator>>(basic_streambuf<char_type,traits>* sb);
+
+#ifdef __UCLIBCXX_HAS_FLOATS__
+		basic_istream<charT,traits>& operator>>(float& f);
+		basic_istream<charT,traits>& operator>>(double& f);
+		basic_istream<charT,traits>& operator>>(long double& f);
+#endif
+
+		_UCXXEXPORT streamsize gcount() const{
+			return count_last_ufmt_input;
+		}
+
+		_UCXXEXPORT int_type get();		//below
+		_UCXXEXPORT basic_istream<charT,traits>& get(char_type& c);	//Below
+
+		_UCXXEXPORT basic_istream<charT,traits>& get(char_type* s, streamsize n){
+			return get(s, n, basic_ios<charT,traits>::widen('\n'));
+		}
+
+		_UCXXEXPORT basic_istream<charT,traits>& get(char_type* s, streamsize n, char_type delim){
+			sentry(*this, true);
+			streamsize i = 0;
+			int_type c;
+			for(i=0;i<n-1;++i){
+				c = basic_ios<charT, traits>::mstreambuf->sgetc();
+				basic_ios<charT, traits>::mstreambuf->sbumpc();
+				if(c == traits::eof() ){
+					if(i==0){
+						basic_ios<charT,traits>::setstate(ios_base::failbit);
+					}else{
+						basic_ios<charT,traits>::setstate(ios_base::eofbit);
+					}
+					break;
+				}
+				if(c == delim){
+					if(i==0){
+						basic_ios<charT,traits>::setstate(ios_base::failbit);
+					}
+					basic_ios<charT, traits>::mstreambuf->sputbackc(c);
+					break;
+				}
+				s[i] = c;
+			}
+			s[i] = traits::eos();
+			count_last_ufmt_input = i;
+			return *this;
+		}
+
+		_UCXXEXPORT basic_istream<charT,traits>& get(basic_streambuf<char_type,traits>& sb){
+			return get(sb, basic_ios<charT,traits>::widen('\n'));
+		}
+
+		_UCXXEXPORT basic_istream<charT,traits>& get(basic_streambuf<char_type,traits>& sb, char_type delim){
+			sentry(*this, true);
+			streamsize i = 0;
+			int_type c;
+			while(1){		//We will exit internally based upon error conditions
+				c = basic_ios<charT, traits>::mstreambuf->sgetc();
+				if(c == traits::eof()){
+					if(i==0){
+						basic_ios<charT,traits>::setstate(ios_base::failbit);
+					}else{
+						basic_ios<charT,traits>::setstate(ios_base::eofbit);
+					}
+					count_last_ufmt_input = i;
+					return *this;
+				}
+				if(c == delim){
+					if(i==0){
+						basic_ios<charT,traits>::setstate(ios_base::failbit);
+					}
+					count_last_ufmt_input = i;
+					return *this;
+				}
+				if(sb.sputc(c) != c){	//Error doing output
+					count_last_ufmt_input = i;
+					return *this;
+				}
+				++i;
+				basic_ios<charT, traits>::mstreambuf->sbumpc();
+			}
+		}
+
+		_UCXXEXPORT basic_istream<charT,traits>& getline(char_type* s, streamsize n){
+			return getline(s, n, basic_ios<charT,traits>::widen('\n'));
+		}
+
+		_UCXXEXPORT basic_istream<charT,traits>& getline(char_type* s, streamsize n, char_type delim){
+			sentry(*this, true);
+			streamsize i = 0;
+			int_type c;
+			for(i=0;i<n-1;++i){
+				c = basic_ios<charT, traits>::mstreambuf->sgetc();
+				if(c == traits::eof() ){
+					if( basic_ios<charT,traits>::eof() ){
+						basic_ios<charT,traits>::setstate(ios_base::failbit);
+					}else{
+						basic_ios<charT,traits>::setstate(ios_base::eofbit);
+					}
+					count_last_ufmt_input = i;
+					s[i] = traits::eos();
+					return *this;
+				}
+				if(basic_ios<charT, traits>::mstreambuf->sbumpc()==traits::eof() ){
+					basic_ios<charT,traits>::setstate(ios_base::eofbit);
+				}
+				if(c == delim){
+					count_last_ufmt_input = i+1;
+					s[i] = traits::eos();
+					return *this;
+				}
+				s[i] = c;
+			}
+			s[n-1] = traits::eos();
+			return *this;
+		}
+
+		_UCXXEXPORT basic_istream<charT,traits>& ignore (streamsize n = 1, int_type delim = traits::eof()){
+			sentry(*this, true);
+			streamsize i;
+			int_type c;
+			for(i=0;i<n;++i){
+				c = basic_ios<charT, traits>::mstreambuf->sgetc();
+				if(c == traits::eof()){
+					basic_ios<charT,traits>::setstate(ios_base::eofbit);
+					return *this;
+				}
+				basic_ios<charT, traits>::mstreambuf->sbumpc();
+				if(c == delim){
+					return *this;
+				}
+			}
+			return *this;
+		}
+
+		_UCXXEXPORT int_type peek(){
+			if(basic_ios<charT,traits>::good() == false){
+				return traits::eof();
+			}else{
+				int_type c = basic_ios<charT, traits>::mstreambuf->sgetc();
+				if(c == traits::eof()){
+					basic_ios<charT,traits>::setstate(ios_base::eofbit);
+				}
+				return basic_ios<charT, traits>::mstreambuf->sgetc();
+			}
+		}
+
+		_UCXXEXPORT basic_istream<charT,traits>& read (char_type* s, streamsize n){
+			sentry(*this, true);
+			streamsize i;
+			int_type c;
+			for(i=0;i<n;++i){
+				c = basic_ios<charT, traits>::mstreambuf->sgetc();
+
+				if(c == traits::eof()){
+					basic_ios<charT,traits>::setstate(ios_base::failbit);
+					basic_ios<charT,traits>::setstate(ios_base::eofbit);
+					count_last_ufmt_input = i;
+					return *this;
+				}
+				basic_ios<charT, traits>::mstreambuf->sbumpc();
+				s[i] = c;
+			}
+			count_last_ufmt_input = n;
+			return *this;
+		}
+
+		_UCXXEXPORT streamsize readsome(char_type* s, streamsize n){
+			sentry(*this, true);
+			if(!basic_ios<charT,traits>::good()){
+				count_last_ufmt_input = 0;
+				basic_ios<charT,traits>::setstate(ios_base::failbit);
+				return 0;
+			}
+
+			if( basic_ios<charT, traits>::mstreambuf->in_avail()  ==  -1){
+				count_last_ufmt_input=0;
+				basic_ios<charT,traits>::setstate(ios_base::eofbit);
+				return 0;
+			}
+
+			if(n > basic_ios<charT, traits>::mstreambuf->in_avail() ){
+				n = basic_ios<charT, traits>::mstreambuf->in_avail();
+			}
+
+			streamsize i;
+			int_type c;
+
+			for(i=0;i<n;++i){
+				c = basic_ios<charT, traits>::mstreambuf->sgetc();
+				basic_ios<charT, traits>::mstreambuf->sbumpc();
+				s[i] = c;
+			}
+			count_last_ufmt_input = n;
+			return n;
+		}
+
+		_UCXXEXPORT basic_istream<charT,traits>& putback(char_type c){
+			sentry(*this, true);
+			if(!basic_ios<charT,traits>::good()){
+				basic_ios<charT,traits>::setstate(ios_base::failbit);
+				return *this;
+			}
+			if(basic_ios<charT, traits>::mstreambuf == 0){
+				basic_ios<charT,traits>::setstate(ios_base::badbit);
+				return *this;
+			}
+			if(basic_ios<charT, traits>::mstreambuf->sputbackc(c) == traits::eof()){
+				basic_ios<charT,traits>::setstate(ios_base::badbit);
+				return *this;
+			}
+			return *this;
+		}
+
+		_UCXXEXPORT basic_istream<charT,traits>& unget(){
+			sentry(*this, true);
+			if(!basic_ios<charT,traits>::good()){
+				basic_ios<charT,traits>::setstate(ios_base::failbit);
+				return *this;
+			}
+			if(basic_ios<charT, traits>::mstreambuf == 0){
+				basic_ios<charT,traits>::setstate(ios_base::failbit);
+				return *this;
+			}
+			if(basic_ios<charT, traits>::mstreambuf->sungetc() == traits::eof()){
+				basic_ios<charT,traits>::setstate(ios_base::failbit);
+			}
+			return *this;
+		}
+
+		_UCXXEXPORT int sync(){
+			sentry(*this, true);
+			if(basic_ios<charT, traits>::mstreambuf == 0){
+				return -1;
+			}
+			if(basic_ios<charT, traits>::mstreambuf->pubsync() == -1){
+				basic_ios<charT,traits>::setstate(ios_base::badbit);
+				return traits::eof();
+			}
+			return 0;
+		}
+
+		_UCXXEXPORT pos_type tellg(){
+			if(basic_ios<charT,traits>::fail() !=false){
+				return pos_type(-1);
+			}
+			return basic_ios<charT, traits>::mstreambuf->pubseekoff(0, ios_base::cur, ios_base::in);
+		}
+
+		_UCXXEXPORT basic_istream<charT,traits>& seekg(pos_type pos){
+			 if(basic_ios<charT,traits>::fail() !=true){
+				basic_ios<charT, traits>::mstreambuf->pubseekpos(pos);
+			 }
+			return *this;
+		}
+
+		_UCXXEXPORT basic_istream<charT,traits>& seekg(off_type off, ios_base::seekdir dir){
+			if(basic_ios<charT,traits>::fail() !=true){
+				basic_ios<charT, traits>::mstreambuf->pubseekoff(off, dir);
+			}
+			return *this;
+		}
+
+	protected:
+		_UCXXEXPORT basic_istream(const basic_istream<charT,traits> &): basic_ios<charT, traits>() { }
+		_UCXXEXPORT basic_istream<charT,traits> & operator=(const basic_istream<charT,traits> &){ return *this; }
+		streamsize count_last_ufmt_input;
+
+	};
+
+	template <class charT,class traits = char_traits<charT> > class _UCXXEXPORT basic_istream<charT,traits>::sentry {
+		bool ok;
+	public:
+		explicit _UCXXEXPORT sentry(basic_istream<charT,traits>& os, bool noskipws = false){
+			if(os.good() !=0){		//Prepare for output
+			}
+
+			//Flush any tied buffer
+			if(os.tie() != 0){
+				os.tie()->flush();
+			}
+			if(!noskipws){
+				__skipws(os);
+			}
+
+			ok = true;
+		}
+		_UCXXEXPORT ~sentry() { }
+		_UCXXEXPORT operator bool() {
+			return ok;
+		}
+	};
+
+	//Template implementations of basic_istream functions which may be partially specialized
+	//For code reduction
+
+	template <class charT, class traits>
+	_UCXXEXPORT typename basic_istream<charT,traits>::int_type basic_istream<charT,traits>::get(){
+		sentry(*this, true);
+		int_type retval = basic_ios<charT, traits>::mstreambuf->sgetc();
+		if(retval == traits::eof()){
+			count_last_ufmt_input = 0;
+			basic_ios<charT,traits>::setstate(ios_base::eofbit);
+		}else{
+			count_last_ufmt_input = 1;
+			basic_ios<charT, traits>::mstreambuf->sbumpc();
+		}
+		return retval;
+	}
+
+	template <class charT, class traits>
+	_UCXXEXPORT basic_istream<charT,traits>& basic_istream<charT,traits>::get(char_type& c){
+		sentry(*this, true);
+		int_type retval = basic_ios<charT, traits>::mstreambuf->sgetc();
+		if(retval == traits::eof()){
+			count_last_ufmt_input = 0;
+			basic_ios<charT,traits>::setstate(ios_base::eofbit);
+			basic_ios<charT,traits>::setstate(ios_base::failbit);
+		}else{
+			count_last_ufmt_input = 1;
+			c = traits::to_char_type(retval);
+			basic_ios<charT, traits>::mstreambuf->sbumpc();
+		}
+		return *this;
+	}
+
+
+	template <class charT, class traits> _UCXXEXPORT basic_istream<charT,traits>&
+		basic_istream<charT,traits>::operator>>(bool& n)
+	{
+		sentry(*this);
+		__istream_readin<traits, charT, bool>::readin(*this, n);
+		return *this;
+	}
+
+	template <class charT, class traits> _UCXXEXPORT basic_istream<charT,traits>&
+		basic_istream<charT,traits>::operator>>(short& n)
+	{
+		sentry(*this);
+		__istream_readin<traits, charT, short>::readin(*this, n);
+		return *this;
+	}
+
+	template <class charT, class traits> _UCXXEXPORT basic_istream<charT,traits>&
+		basic_istream<charT,traits>::operator>>(unsigned short& n)
+	{
+		sentry(*this);
+		__istream_readin<traits, charT, unsigned short>::readin(*this, n);
+		return *this;
+	}
+
+	template <class charT, class traits> _UCXXEXPORT basic_istream<charT,traits>& basic_istream<charT,traits>::operator>>(int& n){
+		sentry(*this);
+		__istream_readin<traits, charT, int>::readin(*this, n);
+		return *this;
+	}
+
+	template <class charT, class traits> _UCXXEXPORT basic_istream<charT,traits>& basic_istream<charT,traits>::operator>>(unsigned int& n){
+		sentry(*this);
+		__istream_readin<traits, charT, unsigned int>::readin(*this, n);
+		return *this;
+	}
+
+	template <class charT, class traits> _UCXXEXPORT basic_istream<charT,traits>& basic_istream<charT,traits>::operator>>(long int& n){
+		sentry(*this);
+		__istream_readin<traits, charT, long int>::readin(*this, n);
+		return *this;
+	}
+
+	template <class charT, class traits> _UCXXEXPORT basic_istream<charT,traits>&
+		basic_istream<charT,traits>::operator>>(unsigned long int& n)
+	{
+		sentry(*this);
+		__istream_readin<traits, charT, unsigned long int>::readin(*this, n);
+		return *this;
+	}
+
+#ifdef __UCLIBCXX_HAS_FLOATS__
+	template <class charT, class traits> _UCXXEXPORT basic_istream<charT,traits>&
+		basic_istream<charT,traits>::operator>>(float& n)
+	{
+		sentry(*this);
+		__istream_readin<traits, charT, float>::readin(*this, n);
+		return *this;
+	}
+	template <class charT, class traits> _UCXXEXPORT basic_istream<charT,traits>&
+		basic_istream<charT,traits>::operator>>(double& n)
+	{
+		sentry(*this);
+		__istream_readin<traits, charT, double>::readin(*this, n);
+		return *this;
+	}
+	template <class charT, class traits> _UCXXEXPORT basic_istream<charT,traits>&
+		basic_istream<charT,traits>::operator>>(long double& n)
+	{
+		sentry(*this);
+		__istream_readin<traits, charT, long double>::readin(*this, n);
+		return *this;
+	}
+#endif
+	template <class charT, class traits> _UCXXEXPORT basic_istream<charT,traits>&
+		basic_istream<charT,traits>::operator>>(void *& n)
+	{
+		sentry(*this);
+		__istream_readin<traits, charT, void*>::readin(*this, n);
+		return *this;
+	}
+
+	template<class charT, class traits> _UCXXEXPORT basic_istream<charT,traits>&
+		operator>>(basic_istream<charT,traits>& is, charT& c)
+	{
+		typename basic_istream<charT,traits>::sentry s(is);
+		is.get(c);
+		return is;
+	}
+
+	template<class traits> _UCXXEXPORT basic_istream<char,traits>&
+		operator>>(basic_istream<char,traits>& is, unsigned char& c)
+	{
+		typename basic_istream<char,traits>::sentry s(is);
+		char b;
+		is.get(b);
+		c = b;
+		return is;
+	}
+	template<class traits> _UCXXEXPORT basic_istream<char,traits>&
+		operator>>(basic_istream<char,traits>& is, signed char& c)
+	{
+		typename basic_istream<char,traits>::sentry s(is);
+		is.get(c);
+		return is;
+	}
+
+	template<class charT, class traits> _UCXXEXPORT basic_istream<charT,traits>&
+		operator>>(basic_istream<charT,traits>& is, charT* c)
+	{
+		typename basic_istream<charT,traits>::sentry s(is);
+		int n = is.width();
+		if(n == 0){
+			n = __STRING_MAX_UNITS;
+		}
+		is.get(c, n);
+		return is;
+
+	}
+	template<class traits> _UCXXEXPORT basic_istream<char,traits>&
+		operator>>(basic_istream<char,traits>& is, unsigned char* c)
+	{
+		typename basic_istream<char,traits>::sentry s(is);
+		int n = is.width();
+		if(n == 0){
+			n = __STRING_MAX_UNITS;
+		}
+		is.get(c, n);
+		return is;
+	}
+	template<class traits> _UCXXEXPORT basic_istream<char,traits>&
+		operator>>(basic_istream<char,traits>& is, signed char* c)
+	{
+		typename basic_istream<char,traits>::sentry s(is);
+		int n = is.width();
+		if(n == 0){
+			n = __STRING_MAX_UNITS;
+		}
+		is.get(c, n);
+		return is;
+	}
+
+	template <class charT, class traits> _UCXXEXPORT basic_istream<charT,traits>&
+		basic_istream<charT,traits>::operator>>(basic_istream<charT,traits>& (*pf)(basic_istream<charT,traits>&))
+	{
+		sentry(*this);
+		pf(*this);
+		return *this;
+	}
+
+	template <class charT, class traits> _UCXXEXPORT basic_istream<charT,traits>&
+		basic_istream<charT,traits>::operator>>(basic_ios<charT,traits>& (*pf)(basic_ios<charT,traits>&))
+	{
+		sentry(*this);
+		pf(*this);
+		return *this;
+	}
+
+	template <class charT, class traits> _UCXXEXPORT basic_istream<charT,traits>&
+		ws(basic_istream<charT,traits>& is)
+	{
+		__skipws(is);
+		return is;
+	}
+
+
+#ifdef __UCLIBCXX_EXPAND_ISTREAM_CHAR__
+#ifndef __UCLIBCXX_COMPILE_ISTREAM__
+
+
+	template <> _UCXXEXPORT istream & basic_istream<char, char_traits<char> >::get(char & c);
+	template <> _UCXXEXPORT istream::int_type basic_istream<char, char_traits<char> >::get();
+
+	template <> _UCXXEXPORT istream & istream::operator>>(bool &n);
+	template <> _UCXXEXPORT istream & istream::operator>>(short &n);
+	template <> _UCXXEXPORT istream & istream::operator>>(unsigned short &n);
+	template <> _UCXXEXPORT istream & istream::operator>>(int &n);
+	template <> _UCXXEXPORT istream & istream::operator>>(unsigned int &n);
+	template <> _UCXXEXPORT istream & istream::operator>>(long unsigned &n);
+	template <> _UCXXEXPORT istream & istream::operator>>(long int &n);
+	template <> _UCXXEXPORT istream & istream::operator>>(void *& p);
+
+#ifdef __UCLIBCXX_HAS_FLOATS__
+	template <> _UCXXEXPORT istream & istream::operator>>(float &f);
+	template <> _UCXXEXPORT istream & istream::operator>>(double &f);
+	template <> _UCXXEXPORT istream & istream::operator>>(long double &f);
+#endif
+
+	template <> _UCXXEXPORT istream & operator>>(istream & is, char & c);
+
+	template <> _UCXXEXPORT void __skipws(basic_istream<char,char_traits<char> >& is);
+
+#endif
+#endif
+
+}
+
+#pragma GCC visibility pop
+
+#endif
+

misc/uClibc++/include/cxx/istream_helpers

@@ -0,0 +1,374 @@
+/*	Copyright (C) 2004 Garrett A. Kajmowicz
+
+	This file is part of the uClibc++ Library.
+
+	This library is free software; you can redistribute it and/or
+	modify it under the terms of the GNU Lesser General Public
+	License as published by the Free Software Foundation; either
+	version 2.1 of the License, or (at your option) any later version.
+
+	This library is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+	Lesser General Public License for more details.
+
+	You should have received a copy of the GNU Lesser General Public
+	License along with this library; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+#include <ios>
+#include <cctype>
+#include <ctype.h>
+
+#include <string>
+
+#ifndef __STD_HEADER_ISTREAM_HELPERS
+#define __STD_HEADER_ISTREAM_HELPERS 1
+
+#pragma GCC visibility push(default)
+
+namespace std{
+
+
+	/* We are making the following template class for serveral reasons.  Firstly,
+	 * we want to keep the main istream code neat and tidy.  Secondly, we want it
+	 * to be easy to do partial specialization of the istream code so that it can
+	 * be expanded and put into the library.  This will allow us to make application
+	 * code smaller at the expense of increased library size.  This is a fair
+	 * trade-off when there are multiple applications being compiled.  Also, this
+	 * feature will be used optionally via configuration options.  It will also
+	 * allow us to keep the code bases in sync, dramatically simplifying the
+	 * maintenance required.  We specialized for char because wchar and others
+	 * require different scanf functions
+	 */
+
+	template <class C, class traits> _UCXXEXPORT
+		basic_string<C, traits> _readToken(basic_istream<C, traits>& stream)
+	{
+		basic_string<C, traits> temp;
+		typename traits::int_type c;
+		while(true){
+			c = stream.rdbuf()->sgetc();
+			if(c != traits::eof() && isspace(c) == false){
+				stream.rdbuf()->sbumpc();
+				temp.append(1, traits::to_char_type(c));
+			}else{
+				break;
+			}
+		}
+		if (temp.size() == 0)
+			stream.setstate(ios_base::eofbit|ios_base::failbit);
+
+		return temp;
+	}
+
+	template <class C, class traits> _UCXXEXPORT
+		basic_string<C, traits> _readTokenDecimal(basic_istream<C, traits>& stream)
+	{
+		basic_string<C, traits> temp;
+		typename traits::int_type c;
+		while(true){
+			c = stream.rdbuf()->sgetc();
+			if(c != traits::eof() && isspace(c) == false && (
+				isdigit(c) ||
+				c == '.' ||
+				c == ',' ||
+				((c == '-' || c == '+') && temp.size() == 0) )
+			){
+				stream.rdbuf()->sbumpc();
+				temp.append(1, traits::to_char_type(c));
+			}else{
+				break;
+			}
+		}
+		if (temp.size() == 0)
+			stream.setstate(ios_base::eofbit|ios_base::failbit);
+
+		return temp;
+	}
+
+#ifdef __UCLIBCXX_EXPAND_ISTREAM_CHAR__
+
+	template <> _UCXXEXPORT string _readToken<char, char_traits<char> >(istream & stream);
+
+#endif
+
+
+	template <class traits, class charT, class dataType> class _UCXXEXPORT __istream_readin{
+	public:
+		static void readin(basic_istream<charT,traits>& stream, dataType & var);
+	};
+
+	template <class traits> class _UCXXEXPORT __istream_readin<traits, char, bool>{
+	public:
+		inline static void readin(basic_istream<char, traits >& stream, bool & var)
+		{
+			/* 22.4.2.1.2.4 */
+			basic_string<char, traits > temp;
+			temp = _readToken( stream);
+			if (stream.flags() & ios_base::boolalpha) {
+				if (temp == "true") // truename()
+					var = true;
+				else {
+					var = false;
+					if (temp != "false") // falsename()
+						stream.setstate(ios_base::failbit);
+				}
+			} else {
+				long int i = 0;
+				int ret;
+				if (stream.flags() & ios_base::dec) {
+					ret = sscanf(temp.c_str(), "%ld", &i );
+				} else {
+					if (stream.flags() & ios_base::oct) {
+						ret = sscanf(temp.c_str(), "%lo", (unsigned long int *)(&i));
+					} else if (stream.flags() & ios_base::hex) {
+						if (stream.flags() & ios_base::uppercase) {
+							ret = sscanf(temp.c_str(), "%lX", (unsigned long int *)(&i));
+						} else {
+							ret = sscanf(temp.c_str(), "%lx", (unsigned long int *)(&i));
+						}
+					} else {
+						ret = sscanf(temp.c_str(), "%li", &i);
+					}
+				}
+				if (ret != 1 || i >> 1)
+					stream.setstate(ios_base::failbit);
+				var = ret == 1 && bool(i);
+			}
+		}
+	};
+
+
+	template <class traits> class _UCXXEXPORT __istream_readin<traits, char, short>{
+	public:
+		inline static void readin(basic_istream<char, traits >& stream, short & var)
+		{
+			basic_string<char, traits > temp;
+
+			if(stream.flags() & ios_base::dec){
+				temp = _readTokenDecimal( stream);
+				sscanf(temp.c_str(), "%hd", &var );
+			}else{
+				temp = _readToken( stream);
+				if( stream.flags() & ios_base::oct){
+					sscanf(temp.c_str(), "%ho", (unsigned short int *)(&var) );
+				}else if(stream.flags() & ios_base::hex){
+					if(stream.flags() & ios_base::uppercase){
+						sscanf(temp.c_str(), "%hX", (unsigned short int *)(&var) );
+					}else{
+						sscanf(temp.c_str(), "%hx", (unsigned short int *)(&var) );
+					}
+				}else{
+					sscanf(temp.c_str(), "%hi", &var);
+				}
+			}
+		}
+	};
+
+	template <class traits> class _UCXXEXPORT __istream_readin<traits, char, unsigned short>{
+	public:
+		inline static void readin(basic_istream<char, traits >& stream, unsigned short & var)
+		{
+			basic_string<char, traits > temp;
+
+			if(stream.flags() & ios_base::dec){
+				temp = _readTokenDecimal( stream);
+				sscanf(temp.c_str(), "%hu", &var );
+			}else{
+				temp = _readToken( stream);
+				if( stream.flags() & ios_base::oct){
+					sscanf(temp.c_str(), "%ho", &var);
+				}else if(stream.flags() & ios_base::hex){
+					if(stream.flags() & ios_base::uppercase){
+						sscanf(temp.c_str(), "%hX", &var );
+					}else{
+						sscanf(temp.c_str(), "%hx", &var);
+					}
+				}else{
+					sscanf(temp.c_str(), "%hi", (signed short int*)(&var) );
+				}
+			}
+		}
+	};
+
+	template <class traits> class _UCXXEXPORT __istream_readin<traits, char, int>{
+	public:
+		inline static void readin(basic_istream<char, traits >& stream, int & var)
+		{
+			basic_string<char, traits > temp;
+
+			if(stream.flags() & ios_base::dec){
+				temp = _readTokenDecimal( stream);
+				sscanf(temp.c_str(), "%d", &var );
+			}else{
+				temp = _readToken( stream);
+				if( stream.flags() & ios_base::oct){
+					sscanf(temp.c_str(), "%o", (unsigned int *)(&var) );
+				}else if(stream.flags() & ios_base::hex){
+					if(stream.flags() & ios_base::uppercase){
+						sscanf(temp.c_str(), "%X", (unsigned int *)(&var) );
+					}else{
+						sscanf(temp.c_str(), "%x", (unsigned int *)(&var) );
+					}
+				}else{
+					sscanf(temp.c_str(), "%i", &var);
+				}
+			}
+		}
+	};
+
+	template <class traits> class _UCXXEXPORT __istream_readin<traits, char, unsigned int>{
+	public:
+		inline static void readin(basic_istream<char, traits >& stream, unsigned int & var)
+		{
+			basic_string<char, traits > temp;
+
+			if(stream.flags() & ios_base::dec){
+				temp = _readTokenDecimal( stream);
+				sscanf(temp.c_str(), "%u", &var );
+			}else{
+				temp = _readToken( stream);
+				if( stream.flags() & ios_base::oct){
+					sscanf(temp.c_str(), "%o", (unsigned int *)(&var) );
+				}else if(stream.flags() & ios_base::hex){
+					if(stream.flags() & ios_base::uppercase){
+						sscanf(temp.c_str(), "%X", (unsigned int *)(&var) );
+					}else{
+						sscanf(temp.c_str(), "%x", (unsigned int *)(&var) );
+					}
+				}else{
+					sscanf(temp.c_str(), "%i", (int *)(&var) );
+				}
+			}
+
+		}
+	};
+
+
+	template <class traits> class _UCXXEXPORT __istream_readin<traits, char, long int>{
+	public:
+		inline static void readin(basic_istream<char, traits >& stream, long int & var)
+		{
+			basic_string<char, traits > temp;
+
+			if(stream.flags() & ios_base::dec){
+				temp = _readTokenDecimal( stream);
+				sscanf(temp.c_str(), "%ld", &var );
+			}else{
+				temp = _readToken( stream);
+				if( stream.flags() & ios_base::oct){
+					sscanf(temp.c_str(), "%lo", (unsigned long int *)(&var) );
+				}else if(stream.flags() & ios_base::hex){
+					if(stream.flags() & ios_base::uppercase){
+						sscanf(temp.c_str(), "%lX", (unsigned long int *)(&var) );
+					}else{
+						sscanf(temp.c_str(), "%lx", (unsigned long int *)(&var) );
+					}
+				}else{
+					sscanf(temp.c_str(), "%li", (long int *)(&var) );
+				}
+			}
+
+		}
+	};
+
+
+	template <class traits> class _UCXXEXPORT __istream_readin<traits, char, unsigned long int>{
+	public:
+		inline static void readin(basic_istream<char, traits >& stream, unsigned long int & var)
+		{
+			basic_string<char, traits > temp;
+
+			if(stream.flags() & ios_base::dec){
+				temp = _readTokenDecimal( stream);
+				sscanf(temp.c_str(), "%lu", &var );
+			}else{
+				temp = _readToken( stream);
+				if( stream.flags() & ios_base::oct){
+					sscanf(temp.c_str(), "%lo", &var );
+				}else if(stream.flags() & ios_base::hex){
+					if(stream.flags() & ios_base::uppercase){
+						sscanf(temp.c_str(), "%lX", &var );
+					}else{
+						sscanf(temp.c_str(), "%lx", &var);
+					}
+				}else{
+					sscanf(temp.c_str(), "%li", (long int *)(&var) );
+				}
+			}
+		}
+	};
+
+
+#ifdef __UCLIBCXX_HAS_FLOATS__
+
+	template <class traits> class _UCXXEXPORT __istream_readin<traits, char, float>{
+	public:
+		inline static void readin(basic_istream<char, traits >& stream, float & var)
+		{
+			basic_string<char, traits > temp;
+			temp = _readTokenDecimal( stream);
+
+			sscanf(temp.c_str(), "%g", &var);
+		}
+	};
+
+	template <class traits> class _UCXXEXPORT __istream_readin<traits, char, double>{
+	public:
+		inline static void readin(basic_istream<char, traits >& stream, double & var)
+		{
+			basic_string<char, traits > temp;
+			temp = _readTokenDecimal( stream);
+			sscanf(temp.c_str(), "%lg", &var);
+		}
+	};
+
+	template <class traits> class _UCXXEXPORT __istream_readin<traits, char, long double>{
+	public:
+		inline static void readin(basic_istream<char, traits >& stream, long double & var)
+		{
+			basic_string<char, traits > temp;
+			temp = _readTokenDecimal( stream);
+			sscanf(temp.c_str(), "%Lg", &var);
+		}
+	};
+
+#endif	// ifdef __UCLIBCXX_HAS_FLOATS__
+
+	template <class traits> class _UCXXEXPORT __istream_readin<traits, char, void*>{
+	public:
+		inline static void readin(basic_istream<char, traits >& stream, void* & var)
+		{
+			basic_string<char, traits > temp;
+			temp = _readToken( stream);
+			sscanf(temp.c_str(), "%p", &var);
+		}
+	};
+
+
+	template<class charT, class traits> void __skipws(basic_istream<charT,traits>& is){
+		const typename basic_istream<charT,traits>::int_type eof = traits::eof();
+		typename basic_istream<charT,traits>::int_type c;
+		//While the next character normally read doesn't equal eof
+		//and that character is a space, advance to the next read position
+		//Thus itterating through all whitespace until we get to the meaty stuff
+		while (
+			!traits::eq_int_type((c = is.rdbuf()->sgetc()),	eof)
+			&& isspace(c)
+		) {
+			is.rdbuf()->sbumpc();
+		}
+		if(traits::eq_int_type(c, eof)){
+			is.setstate(ios_base::eofbit);
+		}
+	}
+}
+
+#pragma GCC visibility pop
+
+#endif
+
+
+

misc/uClibc++/include/cxx/iterator

@@ -0,0 +1,229 @@
+/*	Copyright (C) 2004 Garrett A. Kajmowicz
+
+	This file is part of the uClibc++ Library.
+
+	This library is free software; you can redistribute it and/or
+	modify it under the terms of the GNU Lesser General Public
+	License as published by the Free Software Foundation; either
+	version 2.1 of the License, or (at your option) any later version.
+
+	This library is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+	Lesser General Public License for more details.
+
+	You should have received a copy of the GNU Lesser General Public
+	License along with this library; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+#include <basic_definitions>
+#include <iosfwd>
+#include <cstddef>
+#include <char_traits>
+#include <iterator_base>
+
+
+
+#ifndef __STD_HEADER_ITERATOR
+#define __STD_HEADER_ITERATOR 1
+
+#pragma GCC visibility push(default)
+
+namespace std{
+
+  // subclause _lib.stream.iterators_, stream iterators:
+	template <class T, class charT = char, class traits = char_traits<charT>, class Distance = ptrdiff_t> class istream_iterator;
+	template <class T, class charT, class traits, class Distance> bool
+		operator==(const istream_iterator<T,charT,traits,Distance>& x, const istream_iterator<T,charT,traits,Distance>& y);
+	template <class T, class charT, class traits, class Distance> bool
+		operator!=(const istream_iterator<T,charT,traits,Distance>& x, const istream_iterator<T,charT,traits,Distance>& y);
+	template <class T, class charT = char, class traits = char_traits<charT> > class ostream_iterator;
+	template<class charT, class traits = char_traits<charT> > class istreambuf_iterator;
+	template <class charT, class traits> bool
+		operator==(const istreambuf_iterator<charT,traits>& a, const istreambuf_iterator<charT,traits>& b);
+	template <class charT, class traits> bool
+		operator!=(const istreambuf_iterator<charT,traits>& a, const istreambuf_iterator<charT,traits>& b);
+	template <class charT, class traits = char_traits<charT> > class ostreambuf_iterator;
+
+
+	template < class T, class charT, class traits, class Distance >	class _UCXXEXPORT istream_iterator
+		: public iterator<input_iterator_tag,T,Distance,const T*, const T&>
+	{
+	public:
+		typedef charT char_type;
+		typedef traits traits_type;
+		typedef basic_istream<charT,traits> istream_type;
+		istream_iterator() : in_stream(0), value(0) {}
+		istream_iterator(istream_type& s) : in_stream(&s), value() {
+			*in_stream >> value;
+		}
+		istream_iterator(const istream_iterator<T,charT,traits,Distance>& x)
+			: in_stream(x.in_stream), value(x.value)
+		{ }
+		~istream_iterator() { }
+		const T& operator*() const{
+			return value;
+		}
+		const T* operator->() const{
+			return &value;
+		}
+		istream_iterator<T,charT,traits,Distance>& operator++() {
+			*in_stream >> value;
+			return *this;
+		}
+		istream_iterator<T,charT,traits,Distance>  operator++(int){
+			istream_iterator<T,charT,traits,Distance> tmp = *this;
+			*in_stream >> value;
+			return (tmp);
+		}
+		bool m_equal(const istream_iterator<T,charT,traits,Distance>& x) const{
+			return (in_stream == x.in_stream);
+		}
+	private:
+		basic_istream<charT,traits>* in_stream;
+		T value;
+	};
+
+	template <class T, class charT, class traits, class Distance> _UCXXEXPORT
+		bool operator==(const istream_iterator<T,charT,traits,Distance>& x,
+		const istream_iterator<T,charT,traits,Distance>& y)
+	{
+		return x.m_equal(y);
+	}
+
+	template <class T, class charT, class traits, class Distance> _UCXXEXPORT
+		bool operator!=(const istream_iterator<T,charT,traits,Distance>& x,
+		const istream_iterator<T,charT,traits,Distance>& y)
+	{
+		return !(x == y);
+	}
+
+	template <class T, class charT, class traits> class _UCXXEXPORT ostream_iterator
+		: public iterator<output_iterator_tag,void,void,void,void>
+	{
+	public:
+		typedef charT char_type;
+		typedef traits traits_type;
+		typedef basic_ostream<charT,traits> ostream_type;
+
+		ostream_iterator(ostream_type& s) : out_stream(&s), delim(0) { }
+		ostream_iterator(ostream_type& s, const charT* delimiter) : out_stream(&s), delim(delimiter) { }
+		ostream_iterator(const ostream_iterator<T,charT,traits>& x) : out_stream(x.out_stream), delim(x.delim) { }
+		~ostream_iterator() { }
+		ostream_iterator<T,charT,traits>& operator=(const T& value){
+			*out_stream << value;
+			if(delim != 0){
+				*out_stream << delim;
+			}
+			return (*this);
+		}
+		ostream_iterator<T,charT,traits>& operator*(){ return *this; }
+		ostream_iterator<T,charT,traits>& operator++() { return *this; }
+		ostream_iterator<T,charT,traits> operator++(int) { return *this; }
+	private:
+		basic_ostream<charT,traits>* out_stream;
+		const char* delim;
+	};
+
+	template<class charT, class traits > class _UCXXEXPORT istreambuf_iterator :
+		public iterator<input_iterator_tag, charT, typename traits::off_type, charT*, charT&>
+	{
+	public:
+		typedef charT				char_type;
+		typedef traits				traits_type;
+		typedef typename traits::int_type	int_type;
+		typedef basic_streambuf<charT,traits>	streambuf_type;
+		typedef basic_istream<charT,traits>	istream_type;
+
+		class _UCXXEXPORT proxy{
+			charT val;
+			basic_streambuf<charT, traits> * buf;
+
+			proxy(charT v, basic_streambuf<charT, traits> * b) : val(v), buf(b) { }
+		public:
+			charT operator*() { return val; }
+		};
+
+		istreambuf_iterator() throw() : sbuf(0) { }
+		istreambuf_iterator(istream_type& s) throw() : sbuf(s.rdbuf()) { }
+		istreambuf_iterator(streambuf_type* s) throw() : sbuf(s) { }
+		istreambuf_iterator(const proxy& p) throw() : sbuf(&p.buf) { }
+
+		charT operator*() const{
+			return sbuf->sgetc();
+		}
+		istreambuf_iterator<charT,traits>& operator++(){
+			sbuf->sbumpc();
+			return *this;
+		}
+		proxy operator++(int){
+			istreambuf_iterator<charT,traits> tmp = *this;
+			sbuf->sbumpc();
+			return(tmp);
+		}
+
+		bool equal(const istreambuf_iterator& b) const{
+			return sbuf == b.sbuf || is_eof() && b.is_eof();
+		}
+	private:
+		streambuf_type* sbuf;
+		inline bool is_eof() const{
+			return sbuf == 0 || sbuf->sgetc() == traits_type::eof();
+		}
+	};
+
+	template <class charT, class traits> _UCXXEXPORT bool
+		operator==(const istreambuf_iterator<charT,traits>& a,
+		const istreambuf_iterator<charT,traits>& b)
+	{
+		return a.equal(b);
+	}
+
+	template <class charT, class traits> bool _UCXXEXPORT
+		operator!=(const istreambuf_iterator<charT,traits>& a,
+		const istreambuf_iterator<charT,traits>& b)
+	{
+		return !a.equal(b);
+	}
+
+	template <class charT, class traits> class _UCXXEXPORT ostreambuf_iterator
+		: iterator<output_iterator_tag,void,void,void,void>
+	{
+	public:
+		typedef charT                         char_type;
+		typedef traits                        traits_type;
+		typedef basic_streambuf<charT,traits> streambuf_type;
+		typedef basic_ostream<charT,traits>   ostream_type;
+	public:
+		ostreambuf_iterator(ostream_type& s) throw() : sbuf(s.rdbuf()), f(false) { }
+		ostreambuf_iterator(streambuf_type* s) throw() : sbuf(s), f(false) { }
+		ostreambuf_iterator& operator=(charT c){
+			if(failed() == false){
+				if(sbuf->sputc(c) == traits::eof()){
+					f = true;
+				}
+			}
+			return *this;
+		}
+		ostreambuf_iterator& operator*(){
+			return *this;
+		}
+		ostreambuf_iterator& operator++() { return *this; }
+		ostreambuf_iterator operator++(int) { return *this; }
+		bool failed() const throw(){
+			return f;
+		}
+
+	private:
+		streambuf_type* sbuf;
+		bool f;
+	};
+
+}
+
+#pragma GCC visibility pop
+
+#endif
+
+

misc/uClibc++/include/cxx/iterator_base

@@ -0,0 +1,305 @@
+/*	Copyright (C) 2004 Garrett A. Kajmowicz
+
+	This file is part of the uClibc++ Library.
+
+	This library is free software; you can redistribute it and/or
+	modify it under the terms of the GNU Lesser General Public
+	License as published by the Free Software Foundation; either
+	version 2.1 of the License, or (at your option) any later version.
+
+	This library is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+	Lesser General Public License for more details.
+
+	You should have received a copy of the GNU Lesser General Public
+	License along with this library; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+#include <basic_definitions>
+
+#ifndef __STD_HEADER_ITERATOR_BASE
+#define __STD_HEADER_ITERATOR_BASE 1
+
+#pragma GCC visibility push(default)
+
+namespace std{
+	template<class Iterator> struct iterator_traits;
+	template<class T> struct iterator_traits<T*>;
+
+	template<class Category, class T, class Distance = ptrdiff_t, class Pointer = T*, class Reference = T&> struct iterator;
+
+	struct _UCXXEXPORT input_iterator_tag {};
+	struct _UCXXEXPORT output_iterator_tag {};
+	struct _UCXXEXPORT forward_iterator_tag: public input_iterator_tag {};
+	struct _UCXXEXPORT bidirectional_iterator_tag: public forward_iterator_tag {};
+	struct _UCXXEXPORT random_access_iterator_tag: public bidirectional_iterator_tag {};
+
+	template <class InputIterator, class Distance> _UCXXEXPORT void advance(InputIterator& i, Distance n){
+		while(n > 0){
+			--n;
+			++i;
+		}
+	}
+
+	template <class InputIterator> _UCXXEXPORT typename iterator_traits<InputIterator>::difference_type
+		distance(InputIterator first, InputIterator last)
+	{
+		typename iterator_traits<InputIterator>::difference_type d = 0;
+		while(first++ !=last){
+			d++;
+		}
+		return d;
+	}
+
+  // subclause _lib.predef.iterators_, predefined iterators:
+	template <class Iterator> class reverse_iterator;
+	template <class Iterator> bool operator==(const reverse_iterator<Iterator>& x, const reverse_iterator<Iterator>& y);
+	template <class Iterator> bool operator<(const reverse_iterator<Iterator>& x, const reverse_iterator<Iterator>& y);
+	template <class Iterator> bool operator!=(const reverse_iterator<Iterator>& x, const reverse_iterator<Iterator>& y);
+	template <class Iterator> bool operator>(const reverse_iterator<Iterator>& x, const reverse_iterator<Iterator>& y);
+	template <class Iterator> bool operator>=(const reverse_iterator<Iterator>& x, const reverse_iterator<Iterator>& y);
+	template <class Iterator> bool operator<=(const reverse_iterator<Iterator>& x, const reverse_iterator<Iterator>& y);
+	template <class Iterator> typename reverse_iterator<Iterator>::difference_type
+		operator-( const reverse_iterator<Iterator>& x, const reverse_iterator<Iterator>& y);
+	template <class Iterator> reverse_iterator<Iterator>
+		operator+( typename reverse_iterator<Iterator>::difference_type n, const reverse_iterator<Iterator>& x);
+	template <class Container> class back_insert_iterator;
+	template <class Container> back_insert_iterator<Container> back_inserter(Container& x);
+	template <class Container> class front_insert_iterator;
+	template <class Container> front_insert_iterator<Container> front_inserter(Container& x);
+	template <class Container> class insert_iterator;
+	template <class Container, class Iterator>
+		insert_iterator<Container> inserter(Container& x, Iterator i);
+
+	//Actual Template definitions
+
+	template<class Iterator> struct _UCXXEXPORT iterator_traits {
+		typedef typename Iterator::difference_type difference_type;
+		typedef typename Iterator::value_type value_type;
+		typedef typename Iterator::pointer pointer;
+		typedef typename Iterator::reference reference;
+		typedef typename Iterator::iterator_category iterator_category;
+	};
+
+	//Pointer specialization - required by standard
+	template<class T> struct _UCXXEXPORT iterator_traits<T*> {
+		typedef ptrdiff_t difference_type;
+		typedef T value_type;
+		typedef T* pointer;
+		typedef T& reference;
+		typedef random_access_iterator_tag iterator_category;
+	};
+
+	//Specialization recomended by standard
+/*	template<class T> struct _UCXXEXPORT iterator_traits<T __far*> {
+		typedef long difference_type;
+		typedef T value_type;
+		typedef T __far* pointer;
+		typedef T __far& reference;
+		typedef random_access_iterator_tag iterator_category;
+	};*/
+
+/*	template <class BidirectionalIterator> _UCXXEXPORT void
+		reverse(BidirectionalIterator first, BidirectionalIterator last)
+	{
+		typename iterator_traits<BidirectionalIterator>::difference_type n = distance(first, last);
+		--n;
+		while(n > 0){
+			typename iterator_traits<BidirectionalIterator>::value_type tmp = *first;
+			*first++ = * --last;
+			*last = tmp;
+			n -= 2;
+		}
+	};*/
+
+
+	template <class Category, class T, class Distance, class Pointer, class Reference>
+		struct _UCXXEXPORT iterator
+	{
+		typedef T         value_type;
+		typedef Distance  difference_type;
+		typedef Pointer   pointer;
+		typedef Reference reference;
+		typedef Category  iterator_category;
+	};
+
+
+	template <class Iterator> class _UCXXEXPORT reverse_iterator
+		: public iterator<typename iterator_traits<Iterator>::iterator_category,
+		typename iterator_traits<Iterator>::value_type, typename iterator_traits<Iterator>::difference_type,
+		typename iterator_traits<Iterator>::pointer, typename iterator_traits<Iterator>::reference>
+	{
+	protected:
+		Iterator current;
+		friend bool operator== <Iterator>(const reverse_iterator<Iterator>& x, const reverse_iterator<Iterator>& y);
+		friend bool operator< <Iterator>(const reverse_iterator<Iterator>& x, const reverse_iterator<Iterator>& y);
+
+	public:
+		typedef Iterator iterator_type;
+
+		reverse_iterator() : current(){};
+		explicit reverse_iterator(Iterator x) : current(x) { }
+		template<class U> reverse_iterator(const reverse_iterator<U> &x) : current(x.base()){}
+
+		Iterator base() const { return current; }       // explicit
+
+		typename iterator_traits<Iterator>::reference operator*() const { Iterator tmp = current; return *--tmp; }
+		typename iterator_traits<Iterator>::pointer   operator->() const { return &(operator*()); }
+		typename iterator_traits<Iterator>::reference operator[](typename iterator_traits<Iterator>::difference_type n) const{
+			return current[-n-1];
+		}
+
+		reverse_iterator& operator++(){ --current; return *this;	}
+		reverse_iterator  operator++(int) {reverse_iterator tmp = *this; --current; return tmp; }
+		reverse_iterator& operator--() { ++ current; return *this; }
+		reverse_iterator  operator--(int) {reverse_iterator tmp = *this; ++current; return tmp; }
+
+		reverse_iterator  operator+ (typename iterator_traits<Iterator>::difference_type n) const{
+			reverse_iterator retval( *this );
+			retval+=n;
+			return retval;
+		}
+		reverse_iterator& operator+=(typename iterator_traits<Iterator>::difference_type n){
+			current -= n;
+			return *this;
+		}
+		reverse_iterator operator- (typename iterator_traits<Iterator>::difference_type n) const{
+			reverse_iterator retval( *this );
+			retval-=n;
+			return retval;
+		}
+		reverse_iterator& operator-=(typename iterator_traits<Iterator>::difference_type n){
+			current += n;
+			return *this;
+		}
+	 };
+
+
+	template <class Iterator> _UCXXEXPORT bool
+		operator==(const reverse_iterator<Iterator>& x, const reverse_iterator<Iterator>& y)
+	{
+		return x.base() == y.base();
+	}
+	template <class Iterator> _UCXXEXPORT bool
+		operator<(const reverse_iterator<Iterator>& x, const reverse_iterator<Iterator>& y)
+	{
+		return x.base() < y.base();
+	}
+	template <class Iterator> _UCXXEXPORT bool
+		operator!=(const reverse_iterator<Iterator>& x, const reverse_iterator<Iterator>& y)
+	{
+		return x.base() != y.base();
+	}
+	template <class Iterator> _UCXXEXPORT bool
+		operator>(const reverse_iterator<Iterator>& x, const reverse_iterator<Iterator>& y)
+	{
+		return x.base() > y.base();
+	}
+	template <class Iterator> _UCXXEXPORT bool
+		operator>=(const reverse_iterator<Iterator>& x, const reverse_iterator<Iterator>& y)
+	{
+		return x.base() >= y.base();
+	}
+	template <class Iterator> _UCXXEXPORT bool
+		operator<=(const reverse_iterator<Iterator>& x, const reverse_iterator<Iterator>& y)
+	{
+		return x.base() <= y.base();
+	}
+	template <class Iterator> _UCXXEXPORT typename reverse_iterator<Iterator>::difference_type
+		operator-( const reverse_iterator<Iterator>& x, const reverse_iterator<Iterator>& y)
+	{
+		return y.base() - x.base();
+	}
+	template <class Iterator> _UCXXEXPORT reverse_iterator<Iterator>
+		operator+(typename reverse_iterator<Iterator>::difference_type n, const reverse_iterator<Iterator>& x)
+	{
+		return reverse_iterator<Iterator> (x.base() - n);
+	}
+
+	template <class Container> class _UCXXEXPORT back_insert_iterator :
+		public iterator<output_iterator_tag,void,void,void,void>
+	{
+	protected:
+		Container& container;
+	public:
+		typedef Container container_type;
+		explicit back_insert_iterator(Container& x):container(x) {};
+		back_insert_iterator<Container>& operator=(const typename Container::value_type& value){
+			container.push_back(value);
+			return *this;
+		}
+		back_insert_iterator<Container>& operator*(){
+			return *this;
+		}
+		back_insert_iterator<Container>& operator++(){
+			return *this;
+		}
+		back_insert_iterator<Container>  operator++(int){
+			return *this;
+		}
+	};
+
+	template <class Container> _UCXXEXPORT back_insert_iterator<Container>
+		back_inserter(Container& x)
+	{
+		return back_insert_iterator<Container>(x);
+	}
+
+	template <class Container> class _UCXXEXPORT front_insert_iterator
+		: public iterator<output_iterator_tag,void,void,void,void>
+	{
+	protected:
+		Container& container;
+	public:
+		typedef Container container_type;
+		explicit front_insert_iterator(Container& x): container(x) {}
+		front_insert_iterator<Container>& operator=(const typename Container::value_type& value){
+			container.push_front(value);
+			return *this;
+		}
+
+		front_insert_iterator<Container>& operator*() { return *this; }
+		front_insert_iterator<Container>& operator++() { return *this; }
+		front_insert_iterator<Container> operator++(int) { return *this; }
+	};
+
+	template <class Container> _UCXXEXPORT front_insert_iterator<Container>
+		front_inserter(Container& x)
+	{
+		return front_insert_iterator<Container>(x);
+	}
+
+	template <class Container> class _UCXXEXPORT insert_iterator
+		: public iterator<output_iterator_tag,void,void,void,void>
+	{
+	protected:
+		Container& container;
+		typename Container::iterator iter;
+	public:
+		typedef Container container_type;
+		insert_iterator(Container& x, typename Container::iterator i) : container(x), iter(i) {}
+		insert_iterator<Container>& operator=(const typename Container::value_type& value){
+			iter = container.insert(iter, value);
+			++iter;
+			return *this;
+		}
+		insert_iterator<Container>& operator*() { return *this; }
+		insert_iterator<Container>& operator++() { return *this; }
+		insert_iterator<Container> operator++(int) { return *this; }
+	};
+
+	template <class Container, class Iterator> _UCXXEXPORT insert_iterator<Container>
+		inserter(Container& x, Iterator i)
+	{
+		return insert_iterator<Container>(x,typename Container::iterator(i));
+	}
+
+}
+
+#pragma GCC visibility pop
+
+#endif
+
+

misc/uClibc++/include/cxx/limits

@@ -0,0 +1,663 @@
+/*	Copyright (C) 2006 Garrett A. Kajmowicz
+	This file is part of the uClibc++ Library.
+
+	This library is free software; you can redistribute it and/or
+	modify it under the terms of the GNU Lesser General Public
+	License as published by the Free Software Foundation; either
+	version 2.1 of the License, or (at your option) any later version.
+
+	This library is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+	Lesser General Public License for more details.
+
+	You should have received a copy of the GNU Lesser General Public
+	License along with this library; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+#include <climits>
+
+#ifndef __STD_HEADER_LIMITS
+#define __STD_HEADER_LIMITS 1
+
+#warning limits header is nowhere complete or accurate
+
+#pragma GCC visibility push(default)
+
+namespace std{
+
+enum float_round_style{
+	round_indeterminate		=-1,
+	round_toward_zero		= 0,
+	round_to_nearest		= 1,
+	round_toward_infinity		= 2,
+	round_toward_neg_infinity	= 3
+};
+
+template <int bitsize> struct __bits_to_base_10{
+	static const int size = -1;
+};
+template <> struct __bits_to_base_10<7>{
+	static const int size = 2;
+};
+template <> struct __bits_to_base_10<8>{
+	static const int size = 2;
+};
+template <> struct __bits_to_base_10<9>{
+	static const int size = 2;
+};
+template <> struct __bits_to_base_10<10>{
+	static const int size = 3;
+};
+template <> struct __bits_to_base_10<15>{
+	static const int size = 4;
+};
+template <> struct __bits_to_base_10<16>{
+	static const int size = 4;
+};
+template <> struct __bits_to_base_10<17>{
+	static const int size = 5;
+};
+template <> struct __bits_to_base_10<18>{
+	static const int size = 5;
+};
+template <> struct __bits_to_base_10<31>{
+	static const int size = 9;
+};
+template <> struct __bits_to_base_10<32>{
+	static const int size = 9;
+};
+template <> struct __bits_to_base_10<35>{
+	static const int size = 10;
+};
+template <> struct __bits_to_base_10<36>{
+	static const int size = 10;
+};
+template <> struct __bits_to_base_10<63>{
+	static const int size = 18;
+};
+template <> struct __bits_to_base_10<64>{
+	static const int size = 19;
+};
+template <> struct __bits_to_base_10<71>{
+	static const int size = 21;
+};
+template <> struct __bits_to_base_10<72>{
+	static const int size = 21;
+};
+template <> struct __bits_to_base_10<79>{
+	static const int size = 23;
+};
+template <> struct __bits_to_base_10<80>{
+	static const int size = 24;
+};
+template <> struct __bits_to_base_10<127>{
+	static const int size = 38;
+};
+template <> struct __bits_to_base_10<128>{
+	static const int size = 38;
+};
+
+
+
+
+
+
+template <class T> class numeric_limits {
+public:
+	// General -- meaningful for all specializations.
+
+	static const bool is_specialized = false;
+	static T min();
+	static T max();
+	static const int radix;
+	static const int digits;
+	static const int digits10;
+	static const bool is_signed;
+	static const bool is_integer;
+	static const bool is_exact;
+	static const bool traps;
+	static const bool is_modulo;
+	static const bool is_bounded;
+
+	// Floating point specific.
+
+	static T epsilon();
+	static T round_error();
+	static const int min_exponent10;
+	static const int max_exponent10;
+	static const int min_exponent;
+
+	static const int max_exponent;
+	static const bool has_infinity;
+	static const bool has_quiet_NaN;
+	static const bool has_signaling_NaN;
+	static const bool is_iec559;
+	static const bool has_denorm;
+	static const bool tinyness_before;
+	static const float_round_style round_style;
+	static T denorm_min();
+	static T infinity();
+	static T quiet_NaN();
+	static T signaling_NaN();
+};
+
+template <> class numeric_limits<bool> {
+public:
+	typedef bool T;
+	// General -- meaningful for all specializations.
+	static const bool is_specialized = true;
+	static T min(){
+		return false;
+	}
+	static T max(){
+		return true;
+	}
+	static const int radix = 2;
+	static const int digits = 1;
+	static const int digits10 = 0;
+	static const bool is_signed = false;
+	static const bool is_integer = true;
+	static const bool is_exact = true;
+	static const bool traps = false;
+	static const bool is_modulo = false;
+	static const bool is_bounded = true;
+
+	// Floating point specific.
+
+	static T epsilon(){
+		return 0;
+	}
+	static T round_error(){
+		return 0;
+	}
+	static const int min_exponent10 = 0;
+	static const int max_exponent10 = 0;
+	static const int min_exponent = 0;
+
+	static const int max_exponent = 0;
+	static const bool has_infinity = false;
+	static const bool has_quiet_NaN = false;
+	static const bool has_signaling_NaN = false;
+	static const bool is_iec559 = false;
+	static const bool has_denorm = false;
+	static const bool tinyness_before = false;
+	static const float_round_style round_style = round_indeterminate;
+	static T denorm_min();
+	static T infinity();
+	static T quiet_NaN();
+	static T signaling_NaN();
+};
+
+template <> class numeric_limits<unsigned char> {
+public:
+	typedef unsigned char T;
+	// General -- meaningful for all specializations.
+	static const bool is_specialized = true;
+	static T min(){
+		return 0;
+	}
+	static T max(){
+		return UCHAR_MAX;
+	}
+	static const int radix = 2;
+	static const int digits = CHAR_BIT;
+	static const int digits10 = __bits_to_base_10<digits>::size;
+	static const bool is_signed = false;
+	static const bool is_integer = true;
+	static const bool is_exact = true;
+	static const bool traps = false;
+	static const bool is_modulo = true;
+	static const bool is_bounded = true;
+
+	// Floating point specific.
+
+	static T epsilon(){
+		return 0;
+	}
+	static T round_error(){
+		return 0;
+	}
+	static const int min_exponent10 = 0;
+	static const int max_exponent10 = 0;
+	static const int min_exponent = 0;
+
+	static const int max_exponent = 0;
+	static const bool has_infinity = false;
+	static const bool has_quiet_NaN = false;
+	static const bool has_signaling_NaN = false;
+	static const bool is_iec559 = false;
+	static const bool has_denorm = false;
+	static const bool tinyness_before = false;
+	static const float_round_style round_style = round_indeterminate;
+	static T denorm_min();
+	static T infinity();
+	static T quiet_NaN();
+	static T signaling_NaN();
+};
+
+template <> class numeric_limits<signed char> {
+public:
+	typedef signed char T;
+	// General -- meaningful for all specializations.
+	static const bool is_specialized = true;
+	static T min(){
+		return SCHAR_MIN;
+	}
+	static T max(){
+		return SCHAR_MAX;
+	}
+	static const int radix = 2;
+	static const int digits = CHAR_BIT - 1;
+	static const int digits10 = __bits_to_base_10<digits>::size;
+	static const bool is_signed = true;
+	static const bool is_integer = true;
+	static const bool is_exact = true;
+	static const bool traps = false;
+	static const bool is_modulo = true;
+	static const bool is_bounded = true;
+
+	// Floating point specific.
+
+	static T epsilon(){
+		return 0;
+	}
+	static T round_error(){
+		return 0;
+	}
+	static const int min_exponent10 = 0;
+	static const int max_exponent10 = 0;
+	static const int min_exponent = 0;
+
+	static const int max_exponent = 0;
+	static const bool has_infinity = false;
+	static const bool has_quiet_NaN = false;
+	static const bool has_signaling_NaN = false;
+	static const bool is_iec559 = false;
+	static const bool has_denorm = false;
+	static const bool tinyness_before = false;
+	static const float_round_style round_style = round_indeterminate;
+	static T denorm_min();
+	static T infinity();
+	static T quiet_NaN();
+	static T signaling_NaN();
+};
+
+template <> class numeric_limits<char> {
+public:
+	typedef char T;
+	// General -- meaningful for all specializations.
+	static const bool is_specialized = true;
+	static T min(){
+		return CHAR_MIN;
+	}
+	static T max(){
+		return CHAR_MAX;
+	}
+	static const int radix = 2;
+	static const int digits = (CHAR_MIN != 0) ? CHAR_BIT - 1 : CHAR_BIT;
+	static const int digits10 = __bits_to_base_10<digits>::size;
+	static const bool is_signed = (CHAR_MIN != 0);
+	static const bool is_integer = true;
+	static const bool is_exact = true;
+	static const bool traps = false;
+	static const bool is_modulo = true;
+	static const bool is_bounded = true;
+
+	// Floating point specific.
+
+	static T epsilon(){
+		return 0;
+	}
+	static T round_error(){
+		return 0;
+	}
+	static const int min_exponent10 = 0;
+	static const int max_exponent10 = 0;
+	static const int min_exponent = 0;
+
+	static const int max_exponent = 0;
+	static const bool has_infinity = false;
+	static const bool has_quiet_NaN = false;
+	static const bool has_signaling_NaN = false;
+	static const bool is_iec559 = false;
+	static const bool has_denorm = false;
+	static const bool tinyness_before = false;
+	static const float_round_style round_style = round_indeterminate;
+	static T denorm_min();
+	static T infinity();
+	static T quiet_NaN();
+	static T signaling_NaN();
+};
+
+template <> class numeric_limits<unsigned short> {
+public:
+	typedef unsigned short T;
+	// General -- meaningful for all specializations.
+	static const bool is_specialized = true;
+	static T min(){
+		return 0;
+	}
+	static T max(){
+		return USHRT_MAX;
+	}
+	static const int radix = 2;
+	static const int digits = CHAR_BIT * sizeof(T);
+	static const int digits10 = __bits_to_base_10<digits>::size;
+	static const bool is_signed = false;
+	static const bool is_integer = true;
+	static const bool is_exact = true;
+	static const bool traps = false;
+	static const bool is_modulo = true;
+	static const bool is_bounded = true;
+
+	// Floating point specific.
+
+	static T epsilon(){
+		return 0;
+	}
+	static T round_error(){
+		return 0;
+	}
+	static const int min_exponent10 = 0;
+	static const int max_exponent10 = 0;
+	static const int min_exponent = 0;
+
+	static const int max_exponent = 0;
+	static const bool has_infinity = false;
+	static const bool has_quiet_NaN = false;
+	static const bool has_signaling_NaN = false;
+	static const bool is_iec559 = false;
+	static const bool has_denorm = false;
+	static const bool tinyness_before = false;
+	static const float_round_style round_style = round_indeterminate;
+	static T denorm_min();
+	static T infinity();
+	static T quiet_NaN();
+	static T signaling_NaN();
+};
+
+template <> class numeric_limits<signed short> {
+public:
+	typedef signed short T;
+	// General -- meaningful for all specializations.
+	static const bool is_specialized = true;
+	static T min(){
+		return SHRT_MIN;
+	}
+	static T max(){
+		return SHRT_MAX;
+	}
+	static const int radix = 2;
+	static const int digits = CHAR_BIT * sizeof(T);
+	static const int digits10 = __bits_to_base_10<digits>::size;
+	static const bool is_signed = true;
+	static const bool is_integer = true;
+	static const bool is_exact = true;
+	static const bool traps = false;
+	static const bool is_modulo = true;
+	static const bool is_bounded = true;
+
+	// Floating point specific.
+
+	static T epsilon(){
+		return 0;
+	}
+	static T round_error(){
+		return 0;
+	}
+	static const int min_exponent10 = 0;
+	static const int max_exponent10 = 0;
+	static const int min_exponent = 0;
+
+	static const int max_exponent = 0;
+	static const bool has_infinity = false;
+	static const bool has_quiet_NaN = false;
+	static const bool has_signaling_NaN = false;
+	static const bool is_iec559 = false;
+	static const bool has_denorm = false;
+	static const bool tinyness_before = false;
+	static const float_round_style round_style = round_indeterminate;
+	static T denorm_min();
+	static T infinity();
+	static T quiet_NaN();
+	static T signaling_NaN();
+};
+
+template <> class numeric_limits<unsigned int> {
+public:
+	typedef unsigned int T;
+	// General -- meaningful for all specializations.
+	static const bool is_specialized = true;
+	static T min(){
+		return 0;
+	}
+	static T max(){
+		return UINT_MAX;
+	}
+	static const int radix = 2;
+	static const int digits = CHAR_BIT * sizeof(T);
+	static const int digits10 = __bits_to_base_10<digits>::size;
+	static const bool is_signed = false;
+	static const bool is_integer = true;
+	static const bool is_exact = true;
+	static const bool traps = false;
+	static const bool is_modulo = true;
+	static const bool is_bounded = true;
+
+	// Floating point specific.
+
+	static T epsilon(){
+		return 0;
+	}
+	static T round_error(){
+		return 0;
+	}
+	static const int min_exponent10 = 0;
+	static const int max_exponent10 = 0;
+	static const int min_exponent = 0;
+
+	static const int max_exponent = 0;
+	static const bool has_infinity = false;
+	static const bool has_quiet_NaN = false;
+	static const bool has_signaling_NaN = false;
+	static const bool is_iec559 = false;
+	static const bool has_denorm = false;
+	static const bool tinyness_before = false;
+	static const float_round_style round_style = round_indeterminate;
+	static T denorm_min();
+	static T infinity();
+	static T quiet_NaN();
+	static T signaling_NaN();
+};
+
+template <> class numeric_limits<signed int> {
+public:
+	typedef signed int T;
+	// General -- meaningful for all specializations.
+	static const bool is_specialized = true;
+	static T min(){
+		return INT_MIN;
+	}
+	static T max(){
+		return INT_MAX;
+	}
+	static const int radix = 2;
+	static const int digits = CHAR_BIT * sizeof(T);
+	static const int digits10 = __bits_to_base_10<digits>::size;
+	static const bool is_signed = true;
+	static const bool is_integer = true;
+	static const bool is_exact = true;
+	static const bool traps = false;
+	static const bool is_modulo = true;
+	static const bool is_bounded = true;
+
+	// Floating point specific.
+
+	static T epsilon(){
+		return 0;
+	}
+	static T round_error(){
+		return 0;
+	}
+	static const int min_exponent10 = 0;
+	static const int max_exponent10 = 0;
+	static const int min_exponent = 0;
+
+	static const int max_exponent = 0;
+	static const bool has_infinity = false;
+	static const bool has_quiet_NaN = false;
+	static const bool has_signaling_NaN = false;
+	static const bool is_iec559 = false;
+	static const bool has_denorm = false;
+	static const bool tinyness_before = false;
+	static const float_round_style round_style = round_indeterminate;
+	static T denorm_min();
+	static T infinity();
+	static T quiet_NaN();
+	static T signaling_NaN();
+};
+
+template <> class numeric_limits<unsigned long int> {
+public:
+	typedef unsigned long int T;
+	// General -- meaningful for all specializations.
+	static const bool is_specialized = true;
+	static T min(){
+		return 0;
+	}
+	static T max(){
+		return ULONG_MAX;
+	}
+	static const int radix = 2;
+	static const int digits = CHAR_BIT * sizeof(T);
+	static const int digits10 = __bits_to_base_10<digits>::size;
+	static const bool is_signed = false;
+	static const bool is_integer = true;
+	static const bool is_exact = true;
+	static const bool traps = false;
+	static const bool is_modulo = true;
+	static const bool is_bounded = true;
+
+	// Floating point specific.
+
+	static T epsilon(){
+		return 0;
+	}
+	static T round_error(){
+		return 0;
+	}
+	static const int min_exponent10 = 0;
+	static const int max_exponent10 = 0;
+	static const int min_exponent = 0;
+
+	static const int max_exponent = 0;
+	static const bool has_infinity = false;
+	static const bool has_quiet_NaN = false;
+	static const bool has_signaling_NaN = false;
+	static const bool is_iec559 = false;
+	static const bool has_denorm = false;
+	static const bool tinyness_before = false;
+	static const float_round_style round_style = round_indeterminate;
+	static T denorm_min();
+	static T infinity();
+	static T quiet_NaN();
+	static T signaling_NaN();
+};
+
+template <> class numeric_limits<signed long int> {
+public:
+	typedef signed long int T;
+	// General -- meaningful for all specializations.
+	static const bool is_specialized = true;
+	static T min(){
+		return LONG_MIN;
+	}
+	static T max(){
+		return LONG_MAX;
+	}
+	static const int radix = 2;
+	static const int digits = CHAR_BIT * sizeof(T);
+	static const int digits10 = __bits_to_base_10<digits>::size;
+	static const bool is_signed = true;
+	static const bool is_integer = true;
+	static const bool is_exact = true;
+	static const bool traps = false;
+	static const bool is_modulo = true;
+	static const bool is_bounded = true;
+
+	// Floating point specific.
+
+	static T epsilon(){
+		return 0;
+	}
+	static T round_error(){
+		return 0;
+	}
+	static const int min_exponent10 = 0;
+	static const int max_exponent10 = 0;
+	static const int min_exponent = 0;
+
+	static const int max_exponent = 0;
+	static const bool has_infinity = false;
+	static const bool has_quiet_NaN = false;
+	static const bool has_signaling_NaN = false;
+	static const bool is_iec559 = false;
+	static const bool has_denorm = false;
+	static const bool tinyness_before = false;
+	static const float_round_style round_style = round_indeterminate;
+	static T denorm_min();
+	static T infinity();
+	static T quiet_NaN();
+	static T signaling_NaN();
+};
+
+template <> class numeric_limits<double> {
+public:
+	typedef double numeric_type;
+
+	static const bool is_specialized = true;
+	static numeric_type min () { return __DBL_MIN__; }
+	static numeric_type max () { return __DBL_MAX__; }
+	static const int radix = __FLT_RADIX__;
+	static const int digits = __DBL_MANT_DIG__;
+	static const int digits10 = __DBL_DIG__;
+	static const bool is_signed = true;
+	static const bool is_integer = false;
+	static const bool is_exact = false;
+	static const bool traps = false; // this is a guess
+	static const bool is_modulo = false;
+	static const bool is_bounded = true;
+
+	// Floating point specific.
+
+	static numeric_type epsilon () { return __DBL_EPSILON__; }
+	static numeric_type round_error () { return 0.5; }
+	static const int min_exponent10 = -1; //How do I properly get this?
+	static const int max_exponent10 = -1; //How do I properly get this?
+	static const int min_exponent   = -1; //How do I properly get this?
+	static const int max_exponent   = -1; //How do I properly get this?
+	static const bool has_infinity  = false; //I don't know, so until I can find out, I'm saying no
+	static const bool has_quiet_NaN = false; //I don't know, so until I can find out, I'm saying no
+	static const bool has_signaling_NaN = false; //I don't know, so until I can find out, I'm saying no
+	static const bool has_denorm = false; //I don't know, so until I can find out, I'm saying no
+
+	static const bool is_iec559 = false;  //I don't know, so until I can find out, I'm saying no
+	static const bool tinyness_before = false; // more questions
+	static const float_round_style round_style = round_to_nearest; // more questions
+	static numeric_type denorm_min () { return -1; } //How do I properly get this?
+	static numeric_type infinity () { return -1; } //How do I properly get this?
+	static numeric_type quiet_NaN () { return -1; } //How do I properly get this?
+	static numeric_type signaling_NaN () { return -1; } //How do I properly get this?
+};
+
+
+
+
+
+}
+
+#pragma GCC visibility pop
+
+#endif

misc/uClibc++/include/cxx/list

@@ -0,0 +1,926 @@
+/*	Copyright (C) 2004 Garrett A. Kajmowicz
+
+	This file is part of the uClibc++ Library.
+
+	This library is free software; you can redistribute it and/or
+	modify it under the terms of the GNU Lesser General Public
+	License as published by the Free Software Foundation; either
+	version 2.1 of the License, or (at your option) any later version.
+
+	This library is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+	Lesser General Public License for more details.
+
+	You should have received a copy of the GNU Lesser General Public
+	License along with this library; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+#include <memory>
+#include <iterator>
+#include <algorithm>
+
+#ifndef __STD_HEADER_LIST
+#define __STD_HEADER_LIST 1
+
+#pragma GCC visibility push(default)
+
+namespace std{
+
+	template <class T, class Allocator = allocator<T> > class _UCXXEXPORT list {
+	public:
+		typedef typename Allocator::reference		reference;
+		typedef typename Allocator::const_reference	const_reference;
+		typedef typename Allocator::size_type		size_type;
+		typedef typename Allocator::difference_type	difference_type;
+		typedef T					value_type;
+		typedef Allocator				allocator_type;
+		typedef typename Allocator::pointer		pointer;
+		typedef typename Allocator::const_pointer	const_pointer;
+
+	protected:
+		class node;
+		class iter_list;
+
+		node * list_start;
+		node * list_end;
+		size_type elements;
+		Allocator a;
+
+	public:
+
+		typedef iter_list				iterator;
+		typedef iter_list				const_iterator;
+		typedef std::reverse_iterator<iterator>		reverse_iterator;
+		typedef std::reverse_iterator<const_iterator>	const_reverse_iterator;
+
+		explicit list(const Allocator& = Allocator());
+		explicit list(size_type n, const T& value = T(), const Allocator& = Allocator());
+		template <class InputIterator> list(InputIterator first, InputIterator last,
+			const Allocator& al= Allocator());
+		list(const list<T,Allocator>& x);
+		~list();
+
+		list<T,Allocator>& operator=(const list<T,Allocator>& x){
+			if(&x == this){
+				return *this;
+			}
+			clear();
+			iterator i = x.begin();
+			while(i != x.end()){
+				push_back(*i);
+				++i;
+			}
+			return *this;
+		}
+
+		template <class InputIterator> void assign(InputIterator first, InputIterator last);
+		template <class Size, class U> void assign(Size n, const U& u = U());
+		allocator_type get_allocator() const;
+
+		iterator		begin();
+		const_iterator		begin() const;
+		iterator		end();
+		const_iterator		end() const;
+		reverse_iterator	rbegin();
+		const_reverse_iterator	rbegin() const;
+		reverse_iterator	rend();
+		const_reverse_iterator	rend() const;
+
+		bool      empty() const;
+		size_type size() const;
+		size_type max_size() const;
+		void      resize(size_type sz, T c = T());
+
+		reference       front();
+		const_reference front() const;
+		reference       back();
+		const_reference back() const;
+
+		void push_front(const T& x);
+		void pop_front();
+		void push_back(const T& x);
+		void pop_back();
+		iterator insert(iterator position, const T& x = T());
+		void     insert(iterator position, size_type n, const T& x);
+		template <class InputIterator> void insert(iterator position, InputIterator first, InputIterator last);
+		iterator erase(iterator position);
+		iterator erase(iterator position, iterator last);
+		void     swap(list<T,Allocator>&);
+		void     clear();
+
+		void splice(iterator position, list<T,Allocator>& x);
+		void splice(iterator position, list<T,Allocator>& x, iterator i);
+		void splice(iterator position, list<T,Allocator>& x, iterator first, iterator last);
+		void remove(const T& value);
+		template <class Predicate> void remove_if(Predicate pred);
+		void unique();
+		template <class BinaryPredicate> void unique(BinaryPredicate binary_pred);
+		void merge(list<T,Allocator>& x);
+		template <class Compare> void merge(list<T,Allocator>& x, Compare comp);
+		void sort();
+		template <class Compare> void sort(Compare comp);
+		void reverse();
+	protected:
+		void swap_nodes(node * x, node * y);
+	};
+
+
+	//Implementations of List
+
+	//List node
+	template <class T, class Allocator> class _UCXXEXPORT list<T, Allocator>::node{
+	public:
+		node * previous;
+		node * next;
+		T * val;
+
+		node(): previous(0), next(0), val(0){ }
+		node(const T & t ): previous(0), next(0), val(0) {
+			val = new T(t);
+			//FIXME use allocator somehow but only call constructor once
+		}
+		node(const T & t, node * p, node * n): previous(p), next(n), val(0) {
+			val = new T(t);
+		}
+		~node(){ }
+	};
+
+	//List iterator
+	template <class T, class Allocator> class _UCXXEXPORT list<T, Allocator>::iter_list
+		: public std::iterator<
+			bidirectional_iterator_tag,
+			T,
+			typename Allocator::difference_type,
+			typename Allocator::pointer,
+			typename Allocator::reference
+		>
+	{
+	private:
+		node * current;
+	public:
+		iter_list():current(0) { }
+		iter_list( typename list<T, Allocator>::node * n): current(n) { }
+		iter_list(const list<T, Allocator>::iter_list & l): current(l.current) { }
+		~iter_list(){ }
+
+		iter_list & operator=(const list<T, Allocator>::iter_list & right ){
+			current = right.current;
+			return *this;
+		}
+
+		T & operator*(){
+			return *(current->val);
+		}
+		T * operator->(){
+			return current->val;
+		}
+		const T & operator*() const{
+			return *current->val;
+		}
+		const T * operator->() const{
+			return current->val;
+		}
+
+		bool operator==(const list<T, Allocator>::iter_list & right) const {
+			return (current == right.current);
+		}
+
+		bool operator!=(const list<T, Allocator>::iter_list & right) const {
+			return (current != right.current);
+		}
+
+		iter_list & operator++(){
+			current = current->next;
+			return *this;
+		}
+
+		iter_list operator++(int){
+			iter_list temp(current);
+			current = current->next;
+			return temp;
+		}
+		iter_list & operator--(){
+			current = current->previous;
+			return *this;
+		}
+
+		iter_list operator--(int){
+			iter_list temp(current);
+			current = current->previous;
+			return temp;
+		}
+		node * link_struct(){
+			return current;
+		}
+		iter_list & operator+=(unsigned int n){
+			for(unsigned int i = 0; i < n; ++i){
+				current = current->next;
+			}
+			return *this;
+		}
+		iter_list & operator-=(unsigned int n){
+			for(unsigned int i = 0; i < n; ++i){
+				current = current->previous;
+			}
+			return *this;
+		}
+	};
+
+
+	template<class T, class Allocator> list<T, Allocator>::list(const Allocator& al)
+		:list_start(0), list_end(0), elements(0), a(al)
+	{
+		//End node
+		list_start = new node();
+		list_end = list_start;
+		return;
+	}
+
+	template<class T, class Allocator> list<T, Allocator>::list
+		(typename Allocator::size_type n, const T& value, const Allocator& al)
+		:list_start(0), list_end(0), elements(0), a(al)
+	{
+		//End node
+		list_start = new node();
+		list_end = list_start;
+
+		for(typename Allocator::size_type i = 0; i < n ; ++i){
+			push_back(value);
+		}
+	}
+
+	template<class T, class Allocator> template <class InputIterator>
+		list<T, Allocator>::list
+		(InputIterator first, InputIterator last, const Allocator& al)
+		: list_start(0), list_end(0), elements(0), a(al)
+	{
+		list_start = new node();
+		list_end = list_start;
+		while(first != last){
+			push_back(*first);
+			++first;
+		}
+	}
+
+	template<class T, class Allocator> list<T, Allocator>::list(const list<T,Allocator>& x)
+		: list_start(0), list_end(0), elements(0), a(x.a)
+	{
+		list_start = new node();
+		list_end = list_start;
+
+		iterator i = x.begin();
+		while(i != x.end()){
+			push_back( *i);
+			++i;
+		}
+	}
+
+	template<class T, class Allocator> list<T, Allocator>::~list(){
+		while(elements > 0){
+			pop_front();
+		}
+		delete list_start->val;
+#if UCLIBCXX_DEBUG
+		list_start->val = 0;
+#endif
+		delete list_start;
+#if UCLIBCXX_DEBUG
+		list_start = 0;
+		list_end = 0;
+#endif
+	}
+
+
+	template<class T, class Allocator> void list<T, Allocator>::swap_nodes(node * x, node * y){
+		T * v = x->val;
+		x->val = y->val;
+		y->val = v;
+	}
+
+	template<class T, class Allocator> typename list<T, Allocator>::iterator
+		list<T, Allocator>::begin()
+	{
+		return iterator(list_start);
+	}
+
+
+	template<class T, class Allocator> typename list<T, Allocator>::const_iterator
+		list<T, Allocator>::begin() const
+	{
+		return const_iterator(list_start);
+	}
+
+
+	template<class T, class Allocator> typename list<T, Allocator>::iterator
+		list<T, Allocator>::end()
+	{
+		return iterator(list_end);
+	}
+
+	template<class T, class Allocator> typename list<T, Allocator>::const_iterator
+		list<T, Allocator>::end() const
+	{
+		return const_iterator(list_end);
+	}
+
+	template<class T, class Allocator> typename list<T, Allocator>::reverse_iterator
+		list<T, Allocator>::rbegin()
+	{
+		return reverse_iterator(end());
+	}
+
+	template<class T, class Allocator> typename list<T, Allocator>::const_reverse_iterator
+		list<T, Allocator>::rbegin() const
+	{
+		return const_reverse_iterator(end());
+	}
+
+	template<class T, class Allocator> typename list<T, Allocator>::reverse_iterator
+		list<T, Allocator>::rend()
+	{
+		return reverse_iterator(begin());
+	}
+
+	template<class T, class Allocator> typename list<T, Allocator>::const_reverse_iterator
+		list<T, Allocator>::rend() const
+	{
+		return const_reverse_iterator(begin());
+	}
+
+	template<class T, class Allocator> bool list<T, Allocator>::empty() const{
+		return (elements == 0);
+	}
+	template<class T, class Allocator> typename list<T, Allocator>::size_type list<T, Allocator>::size() const{
+		return elements;
+	}
+	template<class T, class Allocator> typename list<T, Allocator>::size_type list<T, Allocator>::max_size() const{
+		return ((size_type)(-1)) / (sizeof(T) + sizeof(node));
+	}
+	template<class T, class Allocator> void list<T, Allocator>::resize(typename Allocator::size_type sz, T c){
+//		if(sz > elements){
+			for(typename Allocator::size_type i = elements; i < sz; ++i){
+				push_back(c);
+			}
+//		}
+//		if(sz < elements){
+			for(typename Allocator::size_type i = elements; i > sz; --i){
+				pop_back();
+			}
+//		}
+	}
+
+	template<class T, class Allocator> typename list<T, Allocator>::reference list<T, Allocator>::front(){
+		return *(list_start->val);
+	}
+	template<class T, class Allocator> typename list<T, Allocator>::const_reference list<T, Allocator>::front() const{
+		return *(list_start->val);
+	}
+	template<class T, class Allocator> typename list<T, Allocator>::reference list<T, Allocator>::back(){
+		return *(list_end->previous->val);
+	}
+	template<class T, class Allocator> typename list<T, Allocator>::const_reference list<T, Allocator>::back() const{
+		return *(list_end->previous->val);
+	}
+
+
+	template<class T, class Allocator> void list<T, Allocator>::push_front(const T& x){
+		node * temp = new node(x);
+		list_start->previous = temp;
+		temp->previous = 0;
+		temp->next = list_start;
+		list_start = temp;
+		++elements;
+	}
+
+	template<class T, class Allocator> void list<T, Allocator>::pop_front(){
+		if(elements > 0){
+			list_start = list_start->next;
+			delete list_start->previous->val;
+#if UCLIBCXX_DEBUG
+			list_start->previous->val = 0;
+			list_start->previous->next = 0;
+			list_start->previous->previous = 0;
+#endif
+			delete list_start->previous;
+			list_start->previous = 0;
+			--elements;
+		}
+	}
+
+	template<class T, class Allocator> void list<T, Allocator>::push_back(const T& x){
+		if(elements == 0){
+			//The list is completely empty
+			list_start = new node(x);
+			list_end->previous = list_start;
+			list_start->previous = 0;
+			list_start->next = list_end;
+			elements = 1;
+		}else{
+			node * temp = new node(x);
+			temp->previous = list_end->previous;
+			temp->next = list_end;
+			list_end->previous->next = temp;
+			list_end->previous = temp;
+			++elements;
+		}
+	}
+
+	template<class T, class Allocator> void list<T, Allocator>::pop_back(){
+		if(elements > 0){
+			node * temp = list_end->previous;
+			if(temp == list_start){
+				list_end->previous = 0;
+				list_start = list_end;
+			}else{
+				temp->previous->next = temp->next;
+				list_end->previous = temp->previous;
+			}
+			delete temp->val;
+#if UCLIBCXX_DEBUG
+			temp->val = 0;
+			temp->next = 0;
+			temp->previous = 0;
+#endif
+			delete temp;
+#if UCLIBCXX_DEBUG
+			temp = 0;
+#endif
+			--elements;
+		}
+	}
+
+
+	template<class T, class Allocator> typename list<T, Allocator>::iterator
+		list<T, Allocator>::insert(iterator position, const T& x)
+	{
+		node * temp = new node(x);
+
+		temp->previous = position.link_struct()->previous;
+		temp->next = position.link_struct();
+
+		if(temp->previous == 0){
+			list_start = temp;
+		}else{
+			position.link_struct()->previous->next = temp;
+		}
+
+		position.link_struct()->previous = temp;
+
+		++elements;
+		--position;
+		return position;
+	}
+
+	template<class T, class Allocator> void list<T, Allocator>::insert(iterator position, size_type n, const T& x){
+		for(typename list<T, Allocator>::size_type i = 0; i < n; ++i){
+			position = insert(position, x);
+		}
+	}
+
+	template<class T, class Allocator> template <class InputIterator> void
+		list<T, Allocator>::insert(iterator position, InputIterator first, InputIterator last)
+	{
+		while(first !=last){
+			insert(position, *first);
+			++first;
+		}
+	}
+	template<class T, class Allocator> typename list<T, Allocator>::iterator
+		list<T, Allocator>::erase(iterator position)
+	{
+		if(position != end() ){
+			node * temp = position.link_struct();
+			if(temp == list_start){
+				++position;
+				temp->next->previous = 0;
+				list_start = temp->next;
+			}else{
+				--position;
+				temp->next->previous = temp->previous;
+				temp->previous->next = temp->next;
+				++position;
+			}
+			delete temp->val;
+#if UCLIBCXX_DEBUG
+			temp->next = 0;
+			temp->previous = 0;
+			temp->val = 0;
+#endif
+			delete temp;
+#if UCLIBCXX_DEBUG
+			temp = 0;
+#endif
+			--elements;
+		}
+		return position;
+	}
+	template<class T, class Allocator> typename list<T, Allocator>::iterator
+		list<T, Allocator>::erase(iterator position, iterator last)
+	{
+		iterator temp = position;
+		while(position !=last){
+			position = erase(position);
+		}
+		return position;
+	}
+	template<class T, class Allocator> void list<T, Allocator>::swap(list<T,Allocator>& l){
+		node * temp;
+		size_type tempel;
+
+		temp = list_start;
+		list_start = l.list_start;
+		l.list_start = temp;
+
+		temp = list_end;
+		list_end = l.list_end;
+		l.list_end = temp;
+
+		tempel = elements;
+		elements = l.elements;
+		l.elements = tempel;
+	}
+	template<class T, class Allocator> void list<T, Allocator>::clear(){
+		while(elements > 0){
+			pop_front();
+		}
+	}
+
+	template<class T, class Allocator>
+		void list<T, Allocator>::splice(iterator position, list<T,Allocator>& x)
+	{
+
+		//Can't add non-existant elements
+		if(x.elements == 0){
+			return;
+		}
+
+		elements += x.elements;
+		x.elements = 0;
+
+
+		//Chaining to the begining
+		if(position == begin()){
+			x.list_end->previous->next = list_start;
+			list_start->previous = x.list_end->previous;
+
+			list_start = x.list_start;
+
+			x.list_start = x.list_end;
+			x.list_end->previous = 0;
+
+			return;
+		}
+
+		//Link everything we need
+		x.list_start->previous = position.link_struct()->previous;
+		position.link_struct()->previous->next = x.list_start;
+
+		position.link_struct()->previous = x.list_end->previous;
+		x.list_end->previous->next = position.link_struct();
+
+		//Clean up the other list
+
+		x.list_start = x.list_end;
+		x.list_end->previous=0;
+
+	}
+
+	template<class T, class Allocator>
+		void list<T, Allocator>::splice(iterator position, list<T,Allocator>& x, iterator i)
+	{
+		//Invalid conditions
+		if( x.elements == 0 || i == position || position.link_struct() == i.link_struct()->next ){
+			return;
+		}
+
+		//Do we need to adjust the begining pointer?
+		if(i == x.begin()){
+			x.list_start = x.list_start->next;
+			x.list_start->previous = 0;
+		}
+
+
+		//Insert at begining special case
+		if(position == begin()){
+
+			i.link_struct()->previous->next = i.link_struct()->next;
+			i.link_struct()->next->previous = i.link_struct()->previous;
+
+			i.link_struct()->previous = 0;
+			i.link_struct()->next = position.link_struct();
+			position.link_struct()->previous = i.link_struct();
+
+			list_start = i.link_struct();
+
+			--x.elements;
+			++elements;
+			return;
+		}
+
+		if( i.link_struct()->previous != 0){
+			i.link_struct()->previous->next = i.link_struct()->next;
+			i.link_struct()->next->previous = i.link_struct()->previous;
+		}else{
+			i.link_struct()->next->previous = 0;
+			x.list_start = i.link_struct()->next;
+		}
+
+		i.link_struct()->previous = position.link_struct()->previous;
+		position.link_struct()->previous->next = i.link_struct();
+
+		i.link_struct()->next = position.link_struct();
+		position.link_struct()->previous = i.link_struct();
+
+		--x.elements;
+		++elements;
+	}
+
+	template<class T, class Allocator>
+		void list<T, Allocator>::splice(iterator position, list<T,Allocator>& x,
+			iterator first, iterator last)
+	{
+		if(x.elements == 0){
+			return;
+		}
+
+		iterator temp;
+		while(first != last){
+			temp = first;
+			++first;
+			splice(position, x, temp);
+		}
+	}
+
+
+	template<class T, class Allocator> void list<T, Allocator>::remove(const T& value){
+		iterator temp = begin();
+		while( temp != end() ){
+			if(*temp == value){
+				temp = erase(temp);
+			}else{
+				++temp;
+			}
+		}
+	}
+
+
+	template<class T, class Allocator> template <class Predicate> void list<T, Allocator>::remove_if(Predicate pred){
+		iterator temp = begin();
+		while( temp != end() ){
+			if( pred(*temp) ){
+				temp = erase(temp);
+			}else{
+				++temp;
+			}
+		}
+	}
+
+
+	template<class T, class Allocator> void list<T, Allocator>::unique(){
+		equal_to<typename iterator_traits<iterator>::value_type> p;
+		unique(p);
+	}
+
+	template<class T, class Allocator> template <class BinaryPredicate>
+		void list<T, Allocator>::unique(BinaryPredicate binary_pred)
+	{
+		iterator temp1 = begin();
+		iterator temp2;
+		++temp1;
+		while( temp1 != end() ){
+			temp2 = temp1;
+			--temp2;
+			if( binary_pred(*temp1, *temp2) ){
+				erase(temp1);
+				temp1 = temp2;
+			}
+			++temp1;
+		}
+	}
+
+	template<class T, class Allocator> void list<T, Allocator>::merge(list<T,Allocator>& x){
+		less<typename iterator_traits<typename list<T, Allocator>::iterator>::value_type> c;
+		merge(x, c);
+	}
+
+	template<class T, class Allocator> template <class Compare>
+		void list<T, Allocator>::merge(list<T,Allocator>& x, Compare comp)
+	{
+		iterator source = x.begin();
+		iterator temp;
+		iterator dest  = begin();
+
+		while(source != x.end()){
+			while( dest != end() && comp (*dest, *source) ){
+				++dest;
+			}
+			++elements;
+			--x.elements;
+
+			temp = source;
+			++temp;
+
+			if(dest == begin()){
+				dest.link_struct()->previous = source.link_struct();
+				source.link_struct()->next = dest.link_struct();
+				source.link_struct()->previous = 0;
+				list_start = source.link_struct();
+			}else{
+				source.link_struct()->previous = dest.link_struct()->previous;
+				dest.link_struct()->previous->next = source.link_struct();
+				source.link_struct()->next = dest.link_struct();
+				dest.link_struct()->previous = source.link_struct();
+			}
+			source = temp;
+		}
+
+		//Fix up x;
+		x.list_start = x.list_end;
+		x.list_start->previous = 0;
+	}
+
+	template<class T, class Allocator> void list<T, Allocator>::sort(){
+		less<typename iterator_traits<typename list<T, Allocator>::iterator>::value_type> c;
+		sort(c);
+	}
+
+	template<class T, class Allocator> template <class Compare>
+		void list<T, Allocator>::sort(Compare comp)
+	{
+		typename list<T, Allocator>::iterator i, j, k;
+
+		//FIXME - bubble sort
+
+		if(elements == 0){
+			return;
+		}
+
+		i = end();
+		--i;
+		while(i != begin()){
+			j = begin();
+			k = j;
+			++k;
+			while(j != i){
+				if( comp(*k, *j) ){
+					swap_nodes(k.link_struct(), j.link_struct());
+				}
+				++j;
+				++k;
+			}
+			--i;
+		}
+	}
+
+
+	template<class T, class Allocator> void list<T, Allocator>::reverse(){
+		if(elements == 0){
+			return;
+		}
+
+		node * current;
+		node * following;
+		node * temp;
+
+		//Need to move the list_end element to the begining
+
+		temp = list_end;
+		list_end = temp->previous;
+		list_end->next = 0;
+
+		list_start->previous = temp;
+		temp->previous = 0;
+		temp->next = list_start;
+		list_start = temp;
+
+		current = list_start;
+
+		while( current != list_end ){
+			following = current->next;
+
+			//Swap the values pointed to/at with the current node
+			temp = current->next;
+			current->next = current->previous;
+			current->previous = temp;
+
+			current = following;
+		}
+
+		//Swap pointers on the end node
+		temp = list_end->next;
+		list_end->next = list_end->previous;
+		list_end->previous = temp;
+
+
+		//Swap the fixed pointers
+		temp = list_start;
+		list_start = list_end;
+		list_end = temp;
+
+	}
+
+	template <class T, class Allocator>
+	bool operator==(const list<T,Allocator>& x, const list<T,Allocator>& y){
+		if(x.size() != y.size()){
+			return false;
+		}
+		typename list<T,Allocator>::const_iterator i = x.begin();
+		typename list<T,Allocator>::const_iterator j = y.begin();
+
+		while(i != x.end()){
+			if( *i != *j){
+				return false;
+			}
+			++i;
+			++j;
+		}
+		return true;
+	}
+
+	template <class T, class Allocator>
+	bool operator< (const list<T,Allocator>& x, const list<T,Allocator>& y){
+		typename list<T,Allocator>::const_iterator i = x.begin();
+		typename list<T,Allocator>::const_iterator j = y.begin();
+		while(i != x.end() && j != y.end()){
+			if( *i < *j){
+				return true;
+			}
+			if(*j < *i){
+				return false;
+			}
+			++i;
+			++j;
+		}
+		return (i == x.end() && j != y.end());
+	}
+
+	template <class T, class Allocator>
+	bool operator!=(const list<T,Allocator>& x, const list<T,Allocator>& y){
+		return !(x == y);
+	}
+
+	template <class T, class Allocator>
+	bool operator> (const list<T,Allocator>& x, const list<T,Allocator>& y){
+		typename list<T,Allocator>::const_iterator i = x.begin();
+		typename list<T,Allocator>::const_iterator j = y.begin();
+		while(i != x.end() && j != y.end()){
+			if( *i > *j){
+				return true;
+			}
+			if( *j > *i){
+				return false;
+			}
+			++i;
+			++j;
+		}
+		return (i != x.end() && j == y.end());
+	}
+
+	template <class T, class Allocator>
+	bool operator>=(const list<T,Allocator>& x, const list<T,Allocator>& y){
+		typename list<T,Allocator>::const_iterator i = x.begin();
+		typename list<T,Allocator>::const_iterator j = y.begin();
+		while(i != x.end() && j != y.end()){
+			if( *i >= *j){
+				return true;
+			}
+			if(*j >= *i){
+				return false;
+			}
+			++i;
+			++j;
+		}
+		return (i != x.end() && j == y.end());
+	}
+
+	template <class T, class Allocator>
+	bool operator<=(const list<T,Allocator>& x, const list<T,Allocator>& y){
+		typename list<T,Allocator>::const_iterator i = x.begin();
+		typename list<T,Allocator>::const_iterator j = y.begin();
+		while(i != x.end() && j != y.end()){
+			if( *i <= *j){
+				return true;
+			}
+			if(*j <= *i){
+				return false;
+			}
+			++i;
+			++j;
+		}
+		return (i == x.end());
+	}
+
+	template <class T, class Allocator>
+	void swap(list<T,Allocator>& x, list<T,Allocator>& y){
+		x.swap(y);
+	}
+
+}
+
+#pragma GCC visibility pop
+
+#endif
+
+

misc/uClibc++/include/cxx/locale

@@ -0,0 +1,83 @@
+/*	Copyright (C) 2004 Garrett A. Kajmowicz
+
+	This file is part of the uClibc++ Library.
+
+	This library is free software; you can redistribute it and/or
+	modify it under the terms of the GNU Lesser General Public
+	License as published by the Free Software Foundation; either
+	version 2.1 of the License, or (at your option) any later version.
+
+	This library is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+	Lesser General Public License for more details.
+
+	You should have received a copy of the GNU Lesser General Public
+	License along with this library; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+#include <basic_definitions>
+#include <cstddef>
+#include <string>
+
+#ifndef __HEADER_STD_LOCALE
+#define __HEADER_STD_LOCALE 1
+
+#pragma GCC visibility push(default)
+
+namespace std{
+	class _UCXXEXPORT locale {
+	public:
+	// types:
+		class facet;
+		class id;
+		typedef unsigned char category;
+
+		static const category
+		none     = 0,
+		collate  = 0x01, ctype    = 0x02,
+		monetary = 0x04, numeric  = 0x08,
+		time = 0x10, messages = 0x20,
+		all = collate | ctype | monetary | numeric | time  | messages;
+
+		// construct/copy/destroy:
+		locale() throw(){
+			return;
+		}
+		locale(const locale& other) throw(){
+			(void)other;
+			return;
+		}
+		locale(const char *) throw(){
+			return;
+		}
+		~locale() throw(){
+			return;
+		}
+
+		const locale& operator=(const locale&) throw(){
+			return *this;
+		}
+		std::string name() const { return "C"; }
+	};
+
+	class _UCXXEXPORT locale::facet {
+		friend class locale;
+		explicit facet(size_t = 0){
+			return;
+		}
+		virtual ~facet(){
+			return;
+		}
+	};
+
+	class _UCXXEXPORT locale::id {
+		id(){ }
+	};
+
+}
+
+#pragma GCC visibility pop
+
+#endif

misc/uClibc++/include/cxx/map

@@ -0,0 +1,264 @@
+/*	Copyright (C) 2004-2007 Garrett A. Kajmowicz
+	This file is part of the uClibc++ Library.
+
+	This library is free software; you can redistribute it and/or
+	modify it under the terms of the GNU Lesser General Public
+	License as published by the Free Software Foundation; either
+	version 2.1 of the License, or (at your option) any later version.
+
+	This library is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+	Lesser General Public License for more details.
+
+	You should have received a copy of the GNU Lesser General Public
+	License along with this library; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+
+
+#include <memory>
+#include <utility>
+#include <iterator>
+#include <associative_base>
+
+
+#ifndef __STD_HEADER_MAP
+#define __STD_HEADER_MAP
+
+#pragma GCC visibility push(default)
+
+namespace std{
+
+
+template<class Key, class T, class Compare = less<Key>, class Allocator = allocator<T> > class map;
+template<class Key, class T, class Compare = less<Key>, class Allocator = allocator<T> > class multimap;
+
+
+	//Compare the keys of the two items
+/*	template<class Key, class T, class Compare, class Allocator> class _UCXXEXPORT 
+		__base_map<Key, T, Compare, Allocator>::value_compare : public binary_function<
+			typename map<Key, T, Compare, Allocator>::value_type,
+			typename map<Key, T, Compare, Allocator>::value_type,
+		bool>
+	{
+		friend class __base_map<Key, T, Compare, Allocator>;
+	protected:
+		Compare comp;
+		value_compare(Compare c) : comp(c) { }
+		~value_compare() {  }
+	public:
+		bool operator()(const value_type& x, const value_type& y) const {
+			return comp(x.first, y.first);
+		}
+	};
+*/
+
+//	value_compare value_comp() const;
+
+
+
+/* This is the implementation for the map container.  As noted above, it deviates
+ * from ISO spec by deriving from a base class in order to reduce code redundancy.
+ * More code could be reduced by convirting to virtual functions (thus allowing
+ * much of the erase and insert code to be duplicated), but that would deviate from
+ * the specifications too much to be worth the risk.
+ */
+
+
+
+//Implementation of map
+
+
+template<class Key, class T, class Compare, class Allocator> class _UCXXEXPORT map
+	: public __single_associative<Key, pair<Key, T>, Compare, Allocator>
+{
+		//Default value of allocator does not meet C++ standard specs, but it works for this library
+		//Deal with it
+
+public:
+
+	typedef	__single_associative<Key, pair<Key, T>, Compare, Allocator>	base;
+	typedef T 								mapped_type;
+	typedef typename base::key_type						key_type;
+	typedef typename base::value_type					value_type;
+	typedef typename base::key_compare					key_compare;
+	typedef typename base::allocator_type					allocator_type;
+	typedef typename base::reference					reference;
+	typedef typename base::const_reference					const_reference;
+	typedef typename base::iterator						iterator;
+	typedef typename base::const_iterator					const_iterator;
+	typedef typename base::size_type					size_type;
+	typedef typename base::difference_type					difference_type;
+	typedef typename base::pointer						pointer;
+	typedef typename base::const_pointer					const_pointer;
+	typedef typename base::reverse_iterator					reverse_iterator;
+	typedef typename base::const_reverse_iterator				const_reverse_iterator;
+
+	static const key_type v_t_k(const value_type v){
+		return v.first;
+	}
+
+//	using base::value_compare;
+
+	explicit map(const Compare& comp = Compare(), const Allocator& al = Allocator())
+		: base(comp, al, v_t_k) {  }
+
+	template <class InputIterator> map(InputIterator first, InputIterator last,
+		const Compare& comp = Compare(), const Allocator& al = Allocator())
+		: base(first, last, comp, al, v_t_k) {  }
+
+	map(const map<Key,T,Compare,Allocator>& x) : base(x) {  }
+	~map() {  }
+
+	using base::operator=;
+	using base::operator==;
+	using base::operator!=;
+
+	using base::insert;
+	using base::erase;
+
+	using base::begin;
+	using base::end;
+	using base::rbegin;
+	using base::rend;
+
+	using base::empty;
+	using base::size;
+	using base::max_size;
+
+	using base::find;
+	using base::count;
+	using base::lower_bound;
+	using base::upper_bound;
+	using base::equal_range;
+	using base::swap;
+
+	reference operator[](const key_type& k){
+		iterator i = lower_bound(k);
+		if (i == end() || base::c(k, i->first)) {
+			i = insert(make_pair(k, T())).first;
+		}
+		return i->second;
+	}
+
+protected:
+	using base::backing;
+};
+
+
+//Implementation of multimap
+
+
+template<class Key, class T, class Compare, class Allocator> class _UCXXEXPORT multimap
+	: public __multi_associative<Key, pair<Key, T>, Compare, Allocator>
+
+{
+		//Default value of allocator does not meet C++ standard specs, but it works for this library
+		//Deal with it
+public:
+
+	typedef	__multi_associative<Key, pair<Key, T>, Compare, Allocator>	base;
+	typedef T 								mapped_type;
+	typedef typename base::key_type						key_type;
+	typedef typename base::value_type					value_type;
+	typedef typename base::key_compare					key_compare;
+	typedef typename base::allocator_type					allocator_type;
+	typedef typename base::reference					reference;
+	typedef typename base::const_reference					const_reference;
+	typedef typename base::iterator						iterator;
+	typedef typename base::const_iterator					const_iterator;
+	typedef typename base::size_type					size_type;
+	typedef typename base::difference_type					difference_type;
+	typedef typename base::pointer						pointer;
+	typedef typename base::const_pointer					const_pointer;
+	typedef typename base::reverse_iterator					reverse_iterator;
+	typedef typename base::const_reverse_iterator				const_reverse_iterator;
+
+	static const key_type v_t_k(const value_type v){
+		return v.first;
+	}
+
+	explicit multimap(const Compare& comp = Compare(), const Allocator& al = Allocator())
+		: base(comp, al, v_t_k) {  }
+
+	template <class InputIterator> multimap(InputIterator first, InputIterator last,
+		const Compare& comp = Compare(), const Allocator& al = Allocator())
+		: base(first, last, comp, al, v_t_k) {  }
+
+
+	multimap(const multimap<Key,T,Compare,Allocator>& x) : base(x) {  }
+	~multimap() {  }
+
+	using base::operator=;
+	using base::operator==;
+	using base::operator!=;
+
+	using base::insert;
+	using base::erase;
+
+	using base::begin;
+	using base::end;
+	using base::rbegin;
+	using base::rend;
+
+	using base::empty;
+	using base::size;
+	using base::max_size;
+
+	using base::find;
+	using base::count;
+	using base::lower_bound;
+	using base::upper_bound;
+	using base::equal_range;
+	using base::swap;
+
+protected:
+
+	using base::c;
+
+};
+
+
+/* Non-member functions.  These are at the end because they are not associated with any
+   particular class.  These will be implemented as I figure out exactly what all of 
+   them are supposed to do, and I have time.
+ */
+
+	template <class Key, class T, class Compare, class Allocator> _UCXXEXPORT bool operator< 
+		(const map<Key,T,Compare,Allocator>& x, const map<Key,T,Compare,Allocator>& y);
+	template <class Key, class T, class Compare, class Allocator> _UCXXEXPORT bool operator!=
+		(const map<Key,T,Compare,Allocator>& x, const map<Key,T,Compare,Allocator>& y);
+	template <class Key, class T, class Compare, class Allocator> _UCXXEXPORT bool operator>
+		(const map<Key,T,Compare,Allocator>& x, const map<Key,T,Compare,Allocator>& y);
+	template <class Key, class T, class Compare, class Allocator> _UCXXEXPORT bool operator>=
+		(const map<Key,T,Compare,Allocator>& x, const map<Key,T,Compare,Allocator>& y);
+	template <class Key, class T, class Compare, class Allocator> _UCXXEXPORT bool operator<=
+		(const map<Key,T,Compare,Allocator>& x, const map<Key,T,Compare,Allocator>& y);
+	template <class Key, class T, class Compare, class Allocator> _UCXXEXPORT void swap
+		(map<Key,T,Compare,Allocator>& x, map<Key,T,Compare,Allocator>& y);
+
+
+	template <class Key, class T, class Compare, class Allocator> _UCXXEXPORT bool operator==
+		(const multimap<Key,T,Compare,Allocator>& x, const multimap<Key,T,Compare,Allocator>& y);
+	template <class Key, class T, class Compare, class Allocator> _UCXXEXPORT bool operator< 
+		(const multimap<Key,T,Compare,Allocator>& x, const multimap<Key,T,Compare,Allocator>& y);
+	template <class Key, class T, class Compare, class Allocator> _UCXXEXPORT bool operator!=
+		(const multimap<Key,T,Compare,Allocator>& x, const multimap<Key,T,Compare,Allocator>& y);
+	template <class Key, class T, class Compare, class Allocator> _UCXXEXPORT bool operator> 
+		(const multimap<Key,T,Compare,Allocator>& x, const multimap<Key,T,Compare,Allocator>& y);
+	template <class Key, class T, class Compare, class Allocator> _UCXXEXPORT bool operator>=
+		(const multimap<Key,T,Compare,Allocator>& x, const multimap<Key,T,Compare,Allocator>& y);
+	template <class Key, class T, class Compare, class Allocator> _UCXXEXPORT bool operator<=
+		(const multimap<Key,T,Compare,Allocator>& x, const multimap<Key,T,Compare,Allocator>& y);
+	template <class Key, class T, class Compare, class Allocator> _UCXXEXPORT void swap
+		(multimap<Key,T,Compare,Allocator>& x, multimap<Key,T,Compare,Allocator>& y);
+
+}
+
+#pragma GCC visibility pop
+
+#endif
+
+	

misc/uClibc++/include/cxx/memory

@@ -0,0 +1,196 @@
+/*	Copyright (C) 2004 Garrett A. Kajmowicz
+
+	This file is part of the uClibc++ Library.
+
+	This library is free software; you can redistribute it and/or
+	modify it under the terms of the GNU Lesser General Public
+	License as published by the Free Software Foundation; either
+	version 2.1 of the License, or (at your option) any later version.
+
+	This library is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+	Lesser General Public License for more details.
+
+	You should have received a copy of the GNU Lesser General Public
+	License along with this library; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+#include <new>
+#include <cstddef>
+#include <cstdlib>
+#include <iterator_base>
+#include <utility>
+#include <cstdio>
+
+#ifndef HEADER_STD_MEMORY
+#define HEADER_STD_MEMORY 1
+
+#pragma GCC visibility push(default)
+
+namespace std{
+
+template <class T> class allocator;
+	// Specialize for void:
+
+template <> class _UCXXEXPORT allocator<void> {
+public:
+	typedef void*       pointer;
+	typedef const void* const_pointer;
+	typedef void  value_type;
+	template <class U> struct rebind { typedef allocator<U> other; };
+};
+
+template <class T> class _UCXXEXPORT allocator{
+public:
+	typedef T value_type;
+	typedef size_t size_type;
+	typedef ptrdiff_t difference_type;
+	
+	typedef T* pointer;
+	typedef const T* const_pointer;
+
+	typedef T& reference;
+	typedef const T& const_reference;
+
+	pointer address(reference r) const { return &r; }
+	const_pointer address(const_reference r) const { return &r; }
+	
+	allocator() throw(){}
+	template <class U> allocator(const allocator<U>& ) throw();
+	~allocator() throw(){}
+
+	//Space for n Ts
+	pointer allocate(size_type n, typename allocator<void>::const_pointer = 0){
+		return (T*)(::operator new( n * sizeof(T) ));
+	}
+	void deallocate(pointer p, size_type){
+		::operator delete(p);
+	}
+
+	//Use placement new to engage the constructor
+	void construct(pointer p, const T& val) { new((void*)p) T(val); }
+	void destroy(pointer p){ ((T*)p)->~T(); }	//Call destructor
+
+	size_type max_size() const throw();
+	template<class U> struct rebind { typedef allocator<U> other; };
+
+};
+
+template <class Out, class T> class _UCXXEXPORT raw_storage_iterator
+	: public iterator<output_iterator_tag, void, void, void, void>
+{
+		Out p;
+
+public:
+	explicit raw_storage_iterator(Out pp) : p (pp) {  }
+	raw_storage_iterator & operator*() { return *this; }
+	raw_storage_iterator & operator=(const T& val) {
+		T* pp = &*p;
+		new(pp) T(val);
+		return *this;
+	}
+
+	raw_storage_iterator & operator++() { ++p; return *this; }
+	raw_storage_iterator operator++(int) {
+		raw_storage_iterator t = *this;
+		++p;
+		return t;
+	}
+};
+
+template <class T> _UCXXEXPORT pair<T*, ptrdiff_t> get_temporary_buffer(ptrdiff_t n){
+	pair<T*, ptrdiff_t> retval;
+	retval.first = static_cast<T*>(malloc(n * sizeof(T)));
+	if(retval.first == 0){
+		retval.second = 0;
+	}else{
+		retval.second = n;
+	}
+	return retval;
+}
+
+template <class T> _UCXXEXPORT void return_temporary_buffer(T* p){
+	free(p);
+}
+
+
+template <class T> class _UCXXEXPORT auto_ptr{
+
+private:
+	T * object;
+	template <class Y> struct auto_ptr_ref{
+		Y * p;
+	};
+
+public:
+
+	typedef T element_type;
+
+	explicit auto_ptr(T* p =0) throw() : object(p){  }
+	auto_ptr(auto_ptr& p) throw() : object(p.release()){ }
+	auto_ptr(auto_ptr_ref<T> r) throw() : object(r.p){
+		r.p = 0;
+	}
+	template<class Y> auto_ptr(auto_ptr<Y>& p) throw() : object(p.release()){ }
+	auto_ptr& operator=(auto_ptr& p) throw(){
+		if(&p == this){
+			return *this;
+		}
+		delete object;
+		object = p.release();
+		return *this;
+	}
+	template<class Y> auto_ptr& operator=(auto_ptr<Y>& p) throw(){
+		if(&p == this){
+			return *this;
+		}
+		delete object;
+		object = p.release();
+		return *this;
+	}
+	~auto_ptr(){
+		delete object;
+	}
+
+	T& operator*() const throw(){
+		return *object;
+	}
+	T* operator->() const throw(){
+		return object;
+	}
+	T* get() const throw(){
+		return object;
+	}
+	T* release() throw(){
+		T * temp(object);
+		object = 0;
+		return temp;
+	}
+	void reset(T * p=0) throw(){
+		if(p != object){
+			delete object;
+			object = p;
+		}
+	}
+	template<class Y> operator auto_ptr_ref<Y>() throw(){
+		auto_ptr_ref<Y> retval;
+		retval.p = object;
+		object = 0;
+		return retval;
+	}
+	template<class Y> operator auto_ptr<Y>() throw(){
+		auto_ptr<Y> retval(object);
+		object = 0;
+		return retval;
+	}
+	
+};
+
+}	//namespace std
+
+#pragma GCC visibility pop
+
+#endif
+

misc/uClibc++/include/cxx/new

@@ -0,0 +1,64 @@
+/*	Copyright (C) 2004 Garrett A. Kajmowicz
+
+	This file is part of the uClibc++ Library.
+
+	This library is free software; you can redistribute it and/or
+	modify it under the terms of the GNU Lesser General Public
+	License as published by the Free Software Foundation; either
+	version 2.1 of the License, or (at your option) any later version.
+
+	This library is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+	Lesser General Public License for more details.
+
+	You should have received a copy of the GNU Lesser General Public
+	License along with this library; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+#include <basic_definitions>
+#include <exception>
+#include <cstddef>
+
+#ifndef __STD_NEW_OPERATOR
+#define __STD_NEW_OPERATOR 1
+
+#pragma GCC visibility push(default)
+
+namespace std{
+	class _UCXXEXPORT bad_alloc : public exception {};
+
+	struct _UCXXEXPORT nothrow_t {};
+	extern const nothrow_t nothrow;
+
+	typedef void (*new_handler)();
+	_UCXXEXPORT new_handler set_new_handler(new_handler new_p) throw();
+}
+
+
+_UCXXEXPORT void* operator new(std::size_t numBytes) throw(std::bad_alloc);
+_UCXXEXPORT void operator delete(void* ptr) throw();
+
+_UCXXEXPORT void* operator new[](std::size_t numBytes) throw(std::bad_alloc);
+_UCXXEXPORT void operator delete[](void * ptr) throw();
+
+#ifndef NO_NOTHROW
+_UCXXEXPORT void* operator new(std::size_t numBytes, const std::nothrow_t& ) throw();
+_UCXXEXPORT void operator delete(void* ptr, const std::nothrow_t& ) throw();
+
+_UCXXEXPORT void* operator new[](std::size_t numBytes, const std::nothrow_t& ) throw();
+_UCXXEXPORT void operator delete[](void* ptr, const std::nothrow_t& ) throw();
+#endif
+
+	/* Placement operators */
+inline void* operator new(std::size_t, void* ptr) throw() {return ptr; }
+inline void operator delete(void* , void *) throw() { }
+	
+inline void* operator new[](std::size_t, void *p) throw() { return p; }
+inline void operator delete[](void* , void *) throw() {}
+
+#pragma GCC visibility pop
+
+#endif
+

misc/uClibc++/include/cxx/numeric

@@ -0,0 +1,161 @@
+/*	Copyright (C) 2004 Garrett A. Kajmowicz
+
+	This file is part of the uClibc++ Library.
+
+	This library is free software; you can redistribute it and/or
+	modify it under the terms of the GNU Lesser General Public
+	License as published by the Free Software Foundation; either
+	version 2.1 of the License, or (at your option) any later version.
+
+	This library is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+	Lesser General Public License for more details.
+
+	You should have received a copy of the GNU Lesser General Public
+	License along with this library; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+#include <basic_definitions>
+#include <exception>
+
+#ifndef __STD_NUMERIC_HEADER
+#define __STD_NUMERIC_HEADER 1
+
+#pragma GCC visibility push(default)
+
+namespace std{
+	template <class InputIterator, class T> _UCXXEXPORT 
+		T accumulate(InputIterator first, InputIterator last, T init)
+	{
+		while(first != last){
+			init = init + *first;
+			++first;
+		}
+		return init;
+	}
+
+	template <class InputIterator, class T, class BinaryOperation> _UCXXEXPORT 
+		T accumulate(InputIterator first, InputIterator last, T init, BinaryOperation binary_op)
+	{
+		while(first != last){
+			init = binary_op(init, *first);
+			++first;
+		}
+		return init;
+	}
+
+
+	template <class InputIterator1, class InputIterator2, class T> _UCXXEXPORT 
+		T inner_product(InputIterator1 first1, InputIterator1 last1,
+			InputIterator2 first2, T init)
+	{
+		while(first1 != last1){
+			init = init + *first1 * *first2;
+			++first1;
+			++first2;
+		}
+		return init;
+	}
+
+	template <class InputIterator1, class InputIterator2, class T,
+		class BinaryOperation1, class BinaryOperation2> _UCXXEXPORT 
+		T inner_product(InputIterator1 first1, InputIterator1 last1,
+			InputIterator2 first2, T init,
+			BinaryOperation1 binary_op1,
+			BinaryOperation2 binary_op2)
+	{
+		while(first1 != last1){
+			init = binary_op1(init, binary_op2(*first1, *first2));
+			++first1;
+			++first2;
+		}
+		return init;
+	}
+
+	template <class InputIterator, class OutputIterator> _UCXXEXPORT 
+		OutputIterator partial_sum(InputIterator first, InputIterator last,
+		OutputIterator result)
+	{
+		OutputIterator temp(result);
+		*result = *first;
+		++first;
+		++result;
+
+		while(first != last){
+			*result = *first + *temp;
+			temp = result;
+			++first;
+			++result;
+		}
+		return result;
+	}
+
+
+	template <class InputIterator, class OutputIterator, class BinaryOperation> _UCXXEXPORT 
+		OutputIterator partial_sum(InputIterator first, InputIterator last,
+		OutputIterator result, BinaryOperation binary_op)
+	{
+		OutputIterator temp(result);
+		*result = *first;
+		++first;
+		++result;
+
+		while(first != last){
+			*result = binary_op(*first, *temp);
+			temp = result;
+			++first;
+			++result;
+		}
+		return result;
+	}
+
+
+	template <class InputIterator, class OutputIterator> _UCXXEXPORT 
+		OutputIterator
+		adjacent_difference(InputIterator first, InputIterator last,
+			OutputIterator result)
+	{
+		OutputIterator temp(first);
+		*result = *first;
+		++first;
+		++result;
+
+		while(first != last){
+			*result = *first - *temp;
+			temp = first;
+			++first;
+			++result;
+		}
+
+		return result;
+	}
+
+
+	template <class InputIterator, class OutputIterator, class BinaryOperation> _UCXXEXPORT 
+		OutputIterator
+		adjacent_difference(InputIterator first, InputIterator last,
+			OutputIterator result, BinaryOperation binary_op)
+	{
+		OutputIterator temp(first);
+		*result = *first;
+		++first;
+		++result;
+
+		while(first != last){
+			*result = binary_op(*first, *temp);
+			temp = first;
+			++first;
+			++result;
+		}
+
+		return result;
+	}
+
+}
+
+#pragma GCC visibility pop
+
+#endif
+

misc/uClibc++/include/cxx/ostream

@@ -0,0 +1,510 @@
+/*	Copyright (C) 2004-2008 Garrett A. Kajmowicz
+
+	This file is part of the uClibc++ Library.
+
+	This library is free software; you can redistribute it and/or
+	modify it under the terms of the GNU Lesser General Public
+	License as published by the Free Software Foundation; either
+	version 2.1 of the License, or (at your option) any later version.
+
+	This library is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+	Lesser General Public License for more details.
+
+	You should have received a copy of the GNU Lesser General Public
+	License along with this library; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+#include <basic_definitions>
+
+#ifndef STD_HEADER_OSTREAM
+#define STD_HEADER_OSTREAM 1
+
+#include <iosfwd>
+#include <streambuf>
+#include <cstdio>
+#include <ios>
+#include <ostream_helpers>
+
+#pragma GCC visibility push(default)
+
+namespace std {
+	template <class charT, class traits > class basic_ostream;
+	typedef basic_ostream<char> ostream;
+
+#ifdef __UCLIBCXX_HAS_WCHAR__
+	typedef basic_ostream<wchar_t> wostream;
+#endif
+
+	template <class charT, class traits> basic_ostream<charT,traits>& endl(basic_ostream<charT,traits>& os);
+	template <class charT, class traits> basic_ostream<charT,traits>& ends(basic_ostream<charT,traits>& os);
+	template <class charT, class traits> basic_ostream<charT,traits>& flush(basic_ostream<charT,traits>& os);
+
+	template <class charT, class traits > class _UCXXEXPORT basic_ostream
+		: virtual public basic_ios<charT,traits>
+	{
+	public:
+
+		typedef charT char_type;
+		typedef typename traits::int_type int_type;
+		typedef typename traits::pos_type pos_type;
+		typedef typename traits::off_type off_type;
+		typedef traits traits_type;
+
+
+		_UCXXEXPORT basic_ostream(basic_streambuf<charT,traits>* sb)
+			: basic_ios<charT, traits>(sb)
+		{
+			basic_ios<charT,traits>::init(sb);
+		}
+		virtual _UCXXEXPORT ~basic_ostream();
+
+		class sentry;
+
+		_UCXXEXPORT basic_ostream<charT,traits>& operator<<(basic_ostream<charT,traits>& (*pf)(basic_ostream<charT,traits>&)){
+			return pf(*this);
+		}
+		_UCXXEXPORT basic_ostream<charT,traits>& operator<<(basic_ios<charT,traits>& (*pf)(basic_ios<charT,traits>&)){
+			pf(*this);
+			return *this;
+		}
+		_UCXXEXPORT basic_ostream<charT,traits>& operator<<(ios_base& (*pf)(ios_base&)){
+			pf(*this);
+			return *this;
+		}
+		basic_ostream<charT,traits>& operator<<(bool n);
+		basic_ostream<charT,traits>& operator<<(short n);
+		basic_ostream<charT,traits>& operator<<(unsigned short n);
+		basic_ostream<charT,traits>& operator<<(int n);
+		basic_ostream<charT,traits>& operator<<(unsigned int n);
+		basic_ostream<charT,traits>& operator<<(long n);
+		basic_ostream<charT,traits>& operator<<(unsigned long n);
+		basic_ostream<charT,traits>& operator<<(float f);
+		basic_ostream<charT,traits>& operator<<(double f);
+		basic_ostream<charT,traits>& operator<<(long double f);
+		basic_ostream<charT,traits>& operator<<(void* p);
+		basic_ostream<charT,traits>& operator<<(basic_streambuf<char_type,traits>* sb);
+
+		_UCXXEXPORT basic_ostream<charT,traits>& put(char_type c){
+			if(basic_ostream<charT,traits>::traits_type::eq_int_type(
+				basic_ios<charT, traits>::mstreambuf->sputc(c),
+				basic_ostream<charT,traits>::traits_type::eof()))
+			{
+				basic_ios<charT,traits>::setstate(ios_base::eofbit);
+			}
+			return *this;
+		}
+		_UCXXEXPORT basic_ostream<charT,traits>& write(const char_type* s, streamsize n){
+			if(basic_ostream<charT,traits>::traits_type::eq_int_type(
+				basic_ios<charT, traits>::mstreambuf->sputn(s, n), 
+				basic_ostream<charT,traits>::traits_type::eof())
+			){
+				basic_ios<charT,traits>::setstate(ios_base::eofbit);
+			}
+			return *this;
+		}
+		_UCXXEXPORT basic_ostream<charT,traits>& flush(){
+			if(basic_ios<charT, traits>::mstreambuf->pubsync() == -1){
+				basic_ios<charT,traits>::setstate(ios_base::badbit);
+			}
+			return *this;
+		}
+		_UCXXEXPORT pos_type tellp(){
+			if(basic_ios<charT,traits>::fail() != false){
+				return pos_type(-1);
+			}
+			return basic_ios<charT,traits>::rdbuf()->pubseekoff(0, ios_base::cur, ios_base::out);
+		}
+		_UCXXEXPORT basic_ostream<charT,traits>& seekp(pos_type pos){
+			if( basic_ios<charT,traits>::fail() != true ){
+				basic_ios<charT,traits>::rdbuf()->pubseekpos(pos);
+			}
+			return *this;
+		}
+		_UCXXEXPORT basic_ostream<charT,traits>& seekp(off_type off, ios_base::seekdir dir){
+			if( basic_ios<charT,traits>::fail() != true){
+				basic_ios<charT,traits>::rdbuf()->pubseekoff(off, dir);
+			}
+			return *this;
+		}
+
+		_UCXXEXPORT void printout(const char_type* s, streamsize n){
+//david
+			streamsize extra = ios::width() - n;
+			if ((ios::flags()&ios::adjustfield) == ios::right){
+				while (extra > 0) {
+					--extra;
+					put(ios::fill());
+				}
+			}
+			write(s, n);
+			if ((ios::flags()&ios::adjustfield) == ios::left) {
+				while (extra > 0) {
+					--extra;
+					put(ios::fill());
+				}
+			}
+			// Width value only applies for the next output operation.  Reset to zero.
+			ios::width(0);
+		}
+
+	protected:
+		basic_ostream(const basic_ostream<charT,traits> &){ }
+		basic_ostream<charT,traits> & operator=(const basic_ostream<charT,traits> &){ return *this; }
+	};
+
+	//Implementations of template functions.  To allow for partial specialization
+
+	template <class charT, class traits> _UCXXEXPORT basic_ostream<charT,traits>::~basic_ostream(){ }
+	
+	template <class charT, class traits> _UCXXEXPORT basic_ostream<charT,traits>& basic_ostream<charT, traits>::operator<<(bool n){
+		sentry s(*this);
+		if( basic_ios<charT,traits>::flags() & ios_base::boolalpha){
+			if(n){
+				printout("true", 4);
+			}else{
+				printout("false", 5);
+			}
+		}else{
+			if(n){
+				printout("1", 1);
+			}else{
+				printout("0", 1);
+			}
+		}
+		if(basic_ios<charT,traits>::flags() & ios_base::unitbuf){
+			flush();
+		}
+		return *this;
+	}
+
+	template <class charT, class traits> _UCXXEXPORT basic_ostream<charT,traits>& 
+		basic_ostream<charT, traits>::operator<<(unsigned short n){
+		sentry s(*this);
+		__ostream_printout<traits, charT, unsigned long int>::printout(*this, n);
+		return *this;
+	}
+
+	template <class charT, class traits> _UCXXEXPORT basic_ostream<charT,traits>& basic_ostream<charT, traits>::operator<<(short n){
+		sentry s(*this);
+		__ostream_printout<traits, charT, long int>::printout(*this, n);
+		return *this;
+	}
+
+	template <class charT, class traits> _UCXXEXPORT basic_ostream<charT,traits>& basic_ostream<charT, traits>::operator<<(int n){
+		sentry s(*this);
+		__ostream_printout<traits, charT, long int>::printout(*this, n);
+		return *this;
+	}
+
+	template <class charT, class traits> _UCXXEXPORT basic_ostream<charT,traits>& basic_ostream<charT, traits>::operator<<(unsigned int n){
+		sentry s(*this);
+		__ostream_printout<traits, charT, unsigned long int>::printout(*this, n);
+		return *this;
+	}
+
+	template <class charT, class traits> _UCXXEXPORT basic_ostream<charT,traits>& basic_ostream<charT, traits>::operator<<(long n){
+		sentry s(*this);
+		__ostream_printout<traits, charT, long >::printout(*this, n);
+		return *this;
+	}
+
+	template <class charT, class traits> _UCXXEXPORT basic_ostream<charT,traits>& 
+		basic_ostream<charT, traits>::operator<<(unsigned long n)
+	{
+		sentry s(*this);
+		__ostream_printout<traits, charT, unsigned long >::printout(*this, n);
+		return *this;
+	}
+
+	template <class charT, class traits> _UCXXEXPORT basic_ostream<charT,traits>& basic_ostream<charT, traits>::operator<<(float f){
+		sentry s(*this);
+		__ostream_printout<traits, charT, double >::printout(*this, f);
+		return *this;
+	}
+
+	template <class charT, class traits> _UCXXEXPORT basic_ostream<charT,traits>& basic_ostream<charT, traits>::operator<<(double f){
+		sentry s(*this);
+		__ostream_printout<traits, charT, double >::printout(*this, f);
+		return *this;
+	}
+
+	template <class charT, class traits> _UCXXEXPORT basic_ostream<charT,traits>& basic_ostream<charT, traits>::operator<<(long double f){
+		sentry s(*this);
+		__ostream_printout<traits, charT, long double >::printout(*this, f);
+		return *this;
+	}
+
+	template <class charT, class traits> _UCXXEXPORT basic_ostream<charT,traits>& basic_ostream<charT, traits>::operator<<(void* p){
+		sentry s(*this);
+		char buffer[20];
+		printout(buffer, snprintf(buffer, 20, "%p", p) );
+		if(basic_ios<charT,traits>::flags() & ios_base::unitbuf){
+			flush();
+		}
+		return *this;
+	}
+
+	template <class charT, class traits> _UCXXEXPORT basic_ostream<charT,traits>& 
+		basic_ostream<charT, traits>::operator<<(basic_streambuf<charT,traits>* sb)
+	{
+		sentry s(*this);
+		if(sb == 0){
+			basic_ios<charT,traits>::setstate(ios_base::badbit);
+			return *this;
+		}
+
+		typename traits::int_type c;
+
+		while(basic_ios<charT,traits>::good() && (c = sb->sbumpc()) != traits::eof() ){
+			put(c);
+		}
+
+		if(basic_ios<charT,traits>::flags() & ios_base::unitbuf){
+			flush();
+		}
+		return *this;
+	}
+
+	/*Template Specializations*/
+
+#ifdef __UCLIBCXX_EXPAND_OSTREAM_CHAR__
+#ifndef __UCLIBCXX_COMPILE_OSTREAM__
+
+#ifdef __UCLIBCXX_EXPAND_CONSTRUCTORS_DESTRUCTORS__
+
+	template <> _UCXXEXPORT ostream::~basic_ostream();
+
+#endif // __UCLIBCXX_EXPAND_CONSTRUCTORS_DESTRUCTORS__
+
+	template <> _UCXXEXPORT ostream & ostream::flush();
+
+	template <> _UCXXEXPORT ostream & ostream::operator<<(bool n);
+	template <> _UCXXEXPORT ostream & ostream::operator<<(short int n);
+	template <> _UCXXEXPORT ostream & ostream::operator<<(unsigned short int n);
+	template <> _UCXXEXPORT ostream & ostream::operator<<(int n);
+	template <> _UCXXEXPORT ostream & ostream::operator<<(unsigned int n);
+	template <> _UCXXEXPORT ostream & ostream::operator<<(long n);
+	template <> _UCXXEXPORT ostream & ostream::operator<<(unsigned long n);
+	template <> _UCXXEXPORT ostream & ostream::operator<<(float f);
+	template <> _UCXXEXPORT ostream & ostream::operator<<(double f);
+	template <> _UCXXEXPORT ostream & ostream::operator<<(long double f);
+	template <> _UCXXEXPORT ostream & ostream::operator<<(void* p);
+	template <> _UCXXEXPORT ostream & ostream::operator<<(basic_streambuf<char, char_traits<char> >* sb);
+#endif
+#endif
+
+	template <class charT,class traits = char_traits<charT> >
+		class _UCXXEXPORT basic_ostream<charT,traits>::sentry
+	{
+		bool ok;
+	public:
+		explicit _UCXXEXPORT sentry(basic_ostream<charT,traits>& os): ok(true){
+//david
+			if(os.good() !=0){		//Prepare for output
+			}
+			//Flush any tied buffer
+			if(os.tie() !=0 ){
+				os.tie()->flush();
+			}
+		}
+		_UCXXEXPORT ~sentry() { }
+		_UCXXEXPORT operator bool() {
+			return ok;
+		}
+	};
+
+
+#ifdef __UCLIBCXX_EXPAND_OSTREAM_CHAR__
+#ifndef __UCLIBCXX_COMPILE_OSTREAM__
+#ifdef __UCLIBCXX_EXPAND_CONSTRUCTORS_DESTRUCTORS__
+
+	template <> _UCXXEXPORT ostream::sentry::sentry(ostream & os);
+	template <> _UCXXEXPORT ostream::sentry::~sentry();
+
+#endif //__UCLIBCXX_EXPAND_CONSTRUCTORS_DESTRUCTORS__
+#endif
+#endif
+
+
+	//Non - class functions
+
+
+	template<class charT, class traits> _UCXXEXPORT basic_ostream<charT,traits>&
+		operator<<(basic_ostream<charT,traits>& out, charT c)
+	{
+		typename basic_ostream<charT,traits>::sentry s(out);
+		out.put(c);
+		return out;
+	}
+	
+	template<class charT, class traits> _UCXXEXPORT basic_ostream<charT,traits>&
+		operator<<(basic_ostream<charT,traits>& out, char c)
+	{
+		typename basic_ostream<charT,traits>::sentry s(out);
+		out.put(c);
+		return out;
+	}
+    
+	template<class traits> _UCXXEXPORT basic_ostream<char,traits>&
+		operator<<(basic_ostream<char,traits>& out, char c)
+	{
+		typename basic_ostream<char,traits>::sentry s(out);
+		out.put(c);
+		return out;
+	}
+    
+    // signed and unsigned
+	template<class traits> _UCXXEXPORT basic_ostream<char,traits>&
+		operator<<(basic_ostream<char,traits>& out, signed char c)
+	{
+		typename basic_ostream<char,traits>::sentry s(out);
+		out.put(c);
+		return out;
+	}
+	
+	template<class traits> _UCXXEXPORT basic_ostream<char,traits>&
+		operator<<(basic_ostream<char,traits>& out, unsigned char c)
+	{
+		typename basic_ostream<char,traits>::sentry s(out);
+		out.put(c);
+		return out;
+	}
+	
+	template<class charT, class traits> _UCXXEXPORT basic_ostream<charT,traits>&
+		operator<<(basic_ostream<charT,traits>& out, const charT* c)
+	{
+		typename basic_ostream<charT,traits>::sentry s(out);
+		out.printout(c, traits::length(c) );
+		return out;
+	}
+	
+	template<class charT, class traits> _UCXXEXPORT basic_ostream<charT,traits>&
+		operator<<(basic_ostream<charT,traits>& out, const char* c)
+	{
+		typename basic_ostream<charT,traits>::sentry s(out);
+		out.printout(c, char_traits<char>::length(c) );
+		return out;
+	}
+//david
+    // partial specializations
+	template<class traits> _UCXXEXPORT basic_ostream<char,traits>&
+		operator<<(basic_ostream<char,traits>& out, const char* c)
+	{
+//add by david
+               /* printf("hello\n");
+                int i;
+                for(i=0;i<traits::length(c);i++)
+                    printf("%c",*(c+i));
+		traits::length(c);*/
+		typename basic_ostream<char,traits>::sentry s(out);
+		out.printout(c, traits::length(c));
+		return out;
+	}
+
+#ifdef __UCLIBCXX_HAS_WCHAR__
+	template<class traits> _UCXXEXPORT basic_ostream<wchar_t,traits>&
+		operator<<(basic_ostream<wchar_t,traits>& out, const char* c)
+	{
+		typename basic_ostream<wchar_t, traits>::sentry s(out);
+		size_t numChars = char_traits<char>::length(c);
+		wchar_t * temp = new wchar_t[numChars];
+
+		for(size_t i=0; i < numChars; ++i){
+			temp[i] = out.widen(c[i]);
+		}
+
+		out.printout(temp, numChars);
+		return out;
+	}
+#endif
+    
+    //  signed and unsigned
+	template<class traits> _UCXXEXPORT basic_ostream<char,traits>&
+		operator<<(basic_ostream<char,traits>& out, const signed char* c)
+	{
+		typename basic_ostream<char,traits>::sentry s(out);
+		out.printout(reinterpret_cast<const char *>(c), traits::length( reinterpret_cast<const char *>(c)));
+		return out;
+	}
+	
+	template<class traits> _UCXXEXPORT basic_ostream<char,traits>&
+		operator<<(basic_ostream<char,traits>& out, const unsigned char* c)
+	{
+		typename basic_ostream<char,traits>::sentry s(out);
+		out.printout(reinterpret_cast<const char *>(c), traits::length( reinterpret_cast<const char *>(c)));
+		return out;
+	}
+
+	template <class charT, class traits> _UCXXEXPORT basic_ostream<charT,traits>&
+		endl(basic_ostream<charT,traits>& os)
+	{
+		typename basic_ostream<charT,traits>::sentry s(os);
+		os.put('\n');
+		os.flush();
+		return os;
+	}
+
+	template <class charT, class traits> _UCXXEXPORT basic_ostream<charT,traits>&
+		ends(basic_ostream<charT,traits>& os)
+	{
+		typename basic_ostream<charT,traits>::sentry s(os);
+		os.put(traits::eos());
+		return os;
+	}
+
+	template <class charT, class traits> _UCXXEXPORT basic_ostream<charT,traits>& flush(basic_ostream<charT,traits>& os){
+		typename basic_ostream<charT,traits>::sentry s(os);
+		os.flush();
+		return os;
+	}
+
+
+#ifdef __UCLIBCXX_EXPAND_OSTREAM_CHAR__
+#ifndef __UCLIBCXX_COMPILE_OSTREAM__
+	template <> _UCXXEXPORT ostream & endl(ostream & os);
+	template <> _UCXXEXPORT ostream & flush(ostream & os);
+	template <> _UCXXEXPORT ostream & operator<<(ostream & out, char c);
+	template <> _UCXXEXPORT ostream & operator<<(ostream & out, const char* c);
+	template <> _UCXXEXPORT ostream & operator<<(ostream & out, unsigned char c);
+	template <> _UCXXEXPORT ostream & operator<<(ostream & out, unsigned const char* c);
+
+#endif
+#endif
+
+
+#ifndef __STRICT_ANSI__
+
+//Support for output of long long data types
+
+template<class Ch, class Tr> _UCXXEXPORT basic_ostream<Ch, Tr>& 
+	operator<<(basic_ostream<Ch, Tr>& os, signed long long int i)
+{
+	typename basic_ostream<Ch, Tr>::sentry s(os);
+	__ostream_printout<Tr, Ch, signed long long int>::printout(os, i);
+	return os;
+}
+
+
+template<class Ch, class Tr> _UCXXEXPORT basic_ostream<Ch, Tr>& 
+	operator<<(basic_ostream<Ch, Tr>& os, unsigned long long int i)
+{
+	typename basic_ostream<Ch, Tr>::sentry s(os);
+	__ostream_printout<Tr, Ch, unsigned long long int>::printout(os, i);
+	return os;
+}
+
+
+#endif	//__STRICT_ANSI__
+
+
+
+
+}
+
+#pragma GCC visibility pop
+
+#endif
+

misc/uClibc++/include/cxx/ostream_helpers

@@ -0,0 +1,491 @@
+/*	Copyright (C) 2004 Garrett A. Kajmowicz
+
+	This file is part of the uClibc++ Library.
+
+	This library is free software; you can redistribute it and/or
+	modify it under the terms of the GNU Lesser General Public
+	License as published by the Free Software Foundation; either
+	version 2.1 of the License, or (at your option) any later version.
+
+	This library is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+	Lesser General Public License for more details.
+
+	You should have received a copy of the GNU Lesser General Public
+	License along with this library; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+#include <basic_definitions>
+#include <cstddef>
+#include <ios>
+#include <cctype>
+#include <string>
+#include <stdio.h>
+
+#ifndef __STD_HEADER_OSTREAM_HELPERS
+#define __STD_HEADER_OSTREAM_HELPERS 1
+
+#pragma GCC visibility push(default)
+
+namespace std{
+
+	/* We are making the following template class for serveral reasons.  Firstly,
+	 * we want to keep the main ostream code neat and tidy.  Secondly, we want it
+	 * to be easy to do partial specialization of the ostream code so that it can
+	 * be expanded and put into the library.  This will allow us to make application
+	 * code smaller at the expense of increased library size.  This is a fair
+	 * trade-off when there are multiple applications being compiled.  Also, this
+	 * feature will be used optionally via configuration options.  It will also
+	 * allow us to keep the code bases in sync, dramatically simplifying the
+	 * maintenance required.  We specialized for char because wchar and others
+	 * require different scanf functions
+	 */
+
+
+
+	template <class traits, class charT, class dataType> class _UCXXEXPORT __ostream_printout{
+	public:
+		static void printout(basic_ostream<charT,traits>& stream, const dataType n);
+	};
+
+	template <class traits> class _UCXXEXPORT __ostream_printout<traits, char, signed long int>{
+	public:
+		static void printout(basic_ostream<char, traits >& stream, const signed long int n)
+		{
+			char buffer[20];
+			const char * c_ld = "%ld";
+			const char * c_lo = "%lo";
+			const char * c_lX = "%lX";
+			const char * c_lx = "%lx";
+			const char * c_hashlo = "%#lo";
+			const char * c_hashlX = "%#lX";
+			const char * c_hashlx = "%#lx";
+
+			const char * formatString=0;
+
+			if( stream.flags() & ios_base::dec){
+				formatString = c_ld;
+			}else if( stream.flags() & ios_base::oct){
+				if( stream.flags() & ios_base::showbase){
+					formatString = c_hashlo;
+				}else{
+					formatString = c_lo;
+				}
+			}else if (stream.flags() & ios_base::hex){
+				if(stream.flags() & ios_base::showbase){
+					if(stream.flags() & ios_base::uppercase){
+						formatString = c_hashlX;
+					}else{
+						formatString = c_hashlx;
+					}
+				}else{
+					if(stream.flags() & ios_base::uppercase){
+						formatString = c_lX;
+					}else{
+						formatString = c_lx;
+					}
+				}
+			}
+
+			stream.printout(buffer, snprintf(buffer, 20, formatString, n) );
+
+			if(stream.flags() & ios_base::unitbuf){
+				stream.flush();
+			}
+
+		}
+	};
+
+	template <class traits> class _UCXXEXPORT __ostream_printout<traits, char, unsigned long int>{
+	public:
+		static void printout(basic_ostream<char, traits >& stream, const unsigned long int n)
+		{
+			char buffer[20];
+			const char * c_lo = "%lo";
+			const char * c_lu = "%lu";
+			const char * c_lX = "%lX";
+			const char * c_lx = "%lx";
+			const char * c_hashlo = "%#lo";
+			const char * c_hashlX = "%#lX";
+			const char * c_hashlx = "%#lx";
+			const char * formatString=0;
+
+			if( stream.flags() & ios_base::dec){
+				formatString = c_lu;
+			}else if( stream.flags() & ios_base::oct){
+				if( stream.flags() & ios_base::showbase){
+					formatString = c_hashlo;
+				}else{
+					formatString = c_lo;
+				}
+			}else if (stream.flags() & ios_base::hex){
+				if(stream.flags() & ios_base::showbase){
+					if(stream.flags() & ios_base::uppercase){
+						formatString = c_hashlX;
+					}else{
+						formatString = c_hashlx;
+					}
+				}else{
+					if(stream.flags() & ios_base::uppercase){
+						formatString = c_lX;
+					}else{
+						formatString = c_lx;
+					}
+				}
+			}
+
+			stream.printout(buffer, snprintf(buffer, 20, formatString, n));
+			if(stream.flags() & ios_base::unitbuf){
+				stream.flush();
+			}
+		}
+	};
+
+#ifndef __STRICT_ANSI__
+
+	template <class traits> class _UCXXEXPORT __ostream_printout<traits, char, signed long long int>{
+	public:
+		static void printout(basic_ostream<char, traits >& stream, const signed long long int n)
+		{
+			char buffer[28];
+			const char * lld = "%lld";
+			const char * llo = "%llo";
+			const char * llX = "%llX";
+			const char * llx = "%llx";
+			const char * hashllo = "%#llo";
+			const char * hashllX = "%#llX";
+			const char * hashllx = "%#llx";
+			const char * formatString=0;
+
+			if( stream.flags() & ios_base::dec){
+				formatString = lld;
+			}else if( stream.flags() & ios_base::oct){
+				if( stream.flags() & ios_base::showbase){
+					formatString = hashllo;
+				}else{
+					formatString = llo;
+				}
+			}else if (stream.flags() & ios_base::hex){
+				if(stream.flags() & ios_base::showbase){
+					if(stream.flags() & ios_base::uppercase){
+						formatString = hashllX;
+					}else{
+						formatString = hashllx;
+					}
+				}else{
+					if(stream.flags() & ios_base::uppercase){
+						formatString = llX;
+					}else{
+						formatString = llx;
+					}
+				}
+			}
+
+			stream.printout(buffer, snprintf(buffer, 27, formatString, n) );
+
+			if(stream.flags() & ios_base::unitbuf){
+				stream.flush();
+			}
+		}
+	};
+
+	template <class traits> class _UCXXEXPORT __ostream_printout<traits, char, unsigned long long int>{
+	public:
+		static void printout(basic_ostream<char, traits >& stream, const unsigned long long int n)
+		{
+			char buffer[28];
+			const char * llo = "%llo";
+			const char * llu = "%llu";
+			const char * llX = "%llX";
+			const char * llx = "%llx";
+			const char * hashllo = "%#llo";
+			const char * hashllX = "%#llX";
+			const char * hashllx = "%#llx";
+			const char * formatString=0;
+
+			if( stream.flags() & ios_base::dec){
+				formatString = llu;
+			}else if( stream.flags() & ios_base::oct){
+				if( stream.flags() & ios_base::showbase){
+					formatString = hashllo;
+				}else{
+					formatString = llo;
+				}
+			}else if (stream.flags() & ios_base::hex){
+				if(stream.flags() & ios_base::showbase){
+					if(stream.flags() & ios_base::uppercase){
+						formatString = hashllX;
+					}else{
+						formatString = hashllx;
+					}
+				}else{
+					if(stream.flags() & ios_base::uppercase){
+						formatString = llX;
+					}else{
+						formatString = llx;
+					}
+				}
+			}
+
+			stream.printout(buffer, snprintf(buffer, 27, formatString, n) );
+
+			if(stream.flags() & ios_base::unitbuf){
+				stream.flush();
+			}
+		}
+	};
+
+
+#endif	//__STRICT_ANSI__
+
+	template <class traits> class _UCXXEXPORT __ostream_printout<traits, char, double>{
+	public:
+		static void printout(basic_ostream<char, traits >& stream, const double f)
+		{
+			char buffer[32];
+			int length;
+			if(stream.flags() & ios_base::scientific){
+				if(stream.flags() & ios_base::uppercase){
+					length = snprintf(buffer, 32, "%*.*E", static_cast<int>(stream.width()),static_cast<int>(stream.precision()), f);
+				}else{
+					length = snprintf(buffer, 32, "%*.*e", static_cast<int>(stream.width()),static_cast<int>(stream.precision()), f);
+				}
+			} else if(stream.flags() & ios_base::fixed){
+				length = snprintf(buffer, 32, "%*.*f",static_cast<int>(stream.width()),static_cast<int>(stream.precision()), f);
+			} else {
+				length = snprintf(buffer, 32, "%*.*g",static_cast<int>(stream.width()),static_cast<int>(stream.precision()), f);
+			}
+			stream.printout(buffer, length);
+			if(stream.flags() & ios_base::unitbuf){
+				stream.flush();
+			}
+		}
+	};
+
+	template <class traits> class _UCXXEXPORT __ostream_printout<traits, char, long double>{
+	public:
+		static void printout(basic_ostream<char, traits >& stream, const long double f)
+		{
+			char buffer[32];
+			int length;
+			if(stream.flags() & ios_base::scientific){
+				if(stream.flags() & ios_base::uppercase){
+					length = snprintf(buffer, 32, "%*.*LE", static_cast<int>(stream.width()), static_cast<int>(stream.precision()), f);
+				}else{
+					length = snprintf(buffer, 32, "%*.*Le", static_cast<int>(stream.width()), static_cast<int>(stream.precision()), f);
+				}
+			} else if(stream.flags() & ios_base::fixed){
+				length = snprintf(buffer, 32, "%*.*Lf", static_cast<int>(stream.width()), static_cast<int>(stream.precision()), f);
+			} else {
+				length = snprintf(buffer, 32, "%*.*Lg", static_cast<int>(stream.width()), static_cast<int>(stream.precision()), f);
+			}
+			stream.printout(buffer, length);
+			if(stream.flags() & ios_base::unitbuf){
+				stream.flush();
+			}
+
+		}
+	};
+
+#ifdef __UCLIBCXX_HAS_WCHAR__
+	template <class traits> class _UCXXEXPORT __ostream_printout<traits, wchar_t, signed long int>{
+	public:
+		static void printout(basic_ostream<wchar_t, traits >& stream, const signed long int n)
+		{
+			wchar_t buffer[20];
+			if( stream.flags() & ios_base::dec){
+				stream.printout(buffer, swprintf(buffer, 20, L"%ld", n));
+			}else if( stream.flags() & ios_base::oct){
+				if( stream.flags() & ios_base::showbase){
+					stream.printout(buffer, swprintf(buffer, 20, L"%#lo", n));
+				}else{
+					stream.printout(buffer, swprintf(buffer, 20, L"%lo", n) );
+				}
+			}else if (stream.flags() & ios_base::hex){
+				if(stream.flags() & ios_base::showbase){
+					if(stream.flags() & ios_base::uppercase){
+						stream.printout(buffer, swprintf(buffer, 20, L"%#lX", n) );
+					}else{
+						stream.printout(buffer, swprintf(buffer, 20, L"%#lx", n) );
+					}
+				}else{
+					if(stream.flags() & ios_base::uppercase){
+						stream.printout(buffer, swprintf(buffer, 20, L"%lX", n) );
+					}else{
+						stream.printout(buffer, swprintf(buffer, 20, L"%lx", n) );
+					}
+				}
+			}
+			if(stream.flags() & ios_base::unitbuf){
+				stream.flush();
+			}
+		}
+	};
+
+	template <class traits> class _UCXXEXPORT __ostream_printout<traits, wchar_t, unsigned long int>{
+	public:
+		static void printout(basic_ostream<wchar_t, traits >& stream, const unsigned long int n)
+		{
+			wchar_t buffer[20];
+			if( stream.flags() & ios_base::dec){
+				stream.printout(buffer, swprintf(buffer, 20, L"%lu", n));
+			}else if( stream.flags() & ios_base::oct){
+				if( stream.flags() & ios_base::showbase){
+					stream.printout(buffer, swprintf(buffer, 20, L"%#lo", n));
+				}else{
+					stream.printout(buffer, swprintf(buffer, 20, L"%lo", n) );
+				}
+			}else if (stream.flags() & ios_base::hex){
+				if(stream.flags() & ios_base::showbase){
+					if(stream.flags() & ios_base::uppercase){
+						stream.printout(buffer, swprintf(buffer, 20, L"%#lX", n) );
+					}else{
+						stream.printout(buffer, swprintf(buffer, 20, L"%#lx", n) );
+					}
+				}else{
+					if(stream.flags() & ios_base::uppercase){
+						stream.printout(buffer, swprintf(buffer, 20, L"%lX", n) );
+					}else{
+						stream.printout(buffer, swprintf(buffer, 20, L"%lx", n) );
+					}
+				}
+			}
+			if(stream.flags() & ios_base::unitbuf){
+				stream.flush();
+			}
+		}
+	};
+
+#ifndef __STRICT_ANSI__
+
+	template <class traits> class _UCXXEXPORT __ostream_printout<traits, wchar_t, signed long long int>{
+	public:
+		static void printout(basic_ostream<wchar_t, traits >& stream, const signed long long int n)
+		{
+			wchar_t buffer[28];
+			if( stream.flags() & ios_base::dec){
+				stream.printout(buffer, swprintf(buffer, 27, L"%lld", n));
+			}else if( stream.flags() & ios_base::oct){
+				if( stream.flags() & ios_base::showbase){
+					stream.printout(buffer, swprintf(buffer, 27, L"%#llo", n));
+				}else{
+					stream.printout(buffer, swprintf(buffer, 27, L"%llo", n) );
+				}
+			}else if (stream.flags() & ios_base::hex){
+				if(stream.flags() & ios_base::showbase){
+					if(stream.flags() & ios_base::uppercase){
+						stream.printout(buffer, swprintf(buffer, 27, L"%#llX", n) );
+					}else{
+						stream.printout(buffer, swprintf(buffer, 27, L"%#llx", n) );
+					}
+				}else{
+					if(stream.flags() & ios_base::uppercase){
+						stream.printout(buffer, swprintf(buffer, 27, L"%llX", n) );
+					}else{
+						stream.printout(buffer, swprintf(buffer, 27, L"%llx", n) );
+					}
+				}
+			}
+			if(stream.flags() & ios_base::unitbuf){
+				stream.flush();
+			}
+		}
+	};
+
+	template <class traits> class _UCXXEXPORT __ostream_printout<traits, wchar_t, unsigned long long int>{
+	public:
+		static void printout(basic_ostream<wchar_t, traits >& stream, const unsigned long long int n)
+		{
+			wchar_t buffer[28];
+			if( stream.flags() & ios_base::dec){
+				stream.printout(buffer, swprintf(buffer, 27, L"%llu", n));
+			}else if( stream.flags() & ios_base::oct){
+				if( stream.flags() & ios_base::showbase){
+					stream.printout(buffer, swprintf(buffer, 27, L"%#llo", n));
+				}else{
+					stream.printout(buffer, swprintf(buffer, 27, L"%llo", n) );
+				}
+			}else if (stream.flags() & ios_base::hex){
+				if(stream.flags() & ios_base::showbase){
+					if(stream.flags() & ios_base::uppercase){
+						stream.printout(buffer, swprintf(buffer, 27, L"%#llX", n) );
+					}else{
+						stream.printout(buffer, swprintf(buffer, 27, L"%#llx", n) );
+					}
+				}else{
+					if(stream.flags() & ios_base::uppercase){
+						stream.printout(buffer, swprintf(buffer, 27, L"%llX", n) );
+					}else{
+						stream.printout(buffer, swprintf(buffer, 27, L"%llx", n) );
+					}
+				}
+			}
+			if(stream.flags() & ios_base::unitbuf){
+				stream.flush();
+			}
+		}
+	};
+
+
+#endif	//__STRICT_ANSI__
+
+	template <class traits> class _UCXXEXPORT __ostream_printout<traits, wchar_t, double>{
+	public:
+		static void printout(basic_ostream<wchar_t, traits >& stream, const double f)
+		{
+			wchar_t buffer[32];
+			wchar_t format_string[32];
+			if(stream.flags() & ios_base::scientific){
+				if(stream.flags() & ios_base::uppercase){
+					swprintf(format_string, 32, L"%%%u.%uE", static_cast<int>(stream.width()), static_cast<unsigned int>(stream.precision()));
+				}else{
+					swprintf(format_string, 32, L"%%%u.%ue", static_cast<int>(stream.width()), static_cast<unsigned int>(stream.precision()));
+				}
+			} else if(stream.flags() & ios_base::fixed){
+				swprintf(format_string, 32, L"%%%u.%uf", static_cast<int>(stream.width()), static_cast<unsigned int>(stream.precision()));
+			} else {
+				swprintf(format_string, 32, L"%%%u.%ug", static_cast<int>(stream.width()), static_cast<unsigned int>(stream.precision()));
+			}
+			stream.printout(buffer, swprintf(buffer, 32, format_string, f) );
+			if(stream.flags() & ios_base::unitbuf){
+				stream.flush();
+			}
+		}
+	};
+
+	template <class traits> class _UCXXEXPORT __ostream_printout<traits, wchar_t, long double>{
+	public:
+		static void printout(basic_ostream<wchar_t, traits >& stream, const long double f)
+		{
+			wchar_t buffer[32];
+			wchar_t format_string[32];
+			if(stream.flags() & ios_base::scientific){
+				if(stream.flags() & ios_base::uppercase){
+					swprintf(format_string, 32, L"%%%u.%uLE", static_cast<unsigned int>(stream.width()), static_cast<unsigned int>(stream.precision()));
+				}else{
+					swprintf(format_string, 32, L"%%%u.%uLe", static_cast<unsigned int>(stream.width()), static_cast<unsigned int>(stream.precision()));
+				}
+			} else if(stream.flags() & ios_base::fixed){
+				swprintf(format_string, 32, L"%%%u.%uLf", static_cast<unsigned int>(stream.width()), static_cast<unsigned int>(stream.precision()));
+			} else {
+				swprintf(format_string, 32, L"%%%u.%uLg", static_cast<unsigned int>(stream.width()), static_cast<unsigned int>(stream.precision()));
+			}
+			stream.printout(buffer, swprintf(buffer, 32, format_string, f) );
+			if(stream.flags() & ios_base::unitbuf){
+				stream.flush();
+			}
+		}
+	};
+
+#endif //__UCLIBCXX_HAS_WCHAR__
+
+}
+
+#pragma GCC visibility pop
+
+#endif
+
+
+

misc/uClibc++/include/cxx/queue

@@ -0,0 +1,126 @@
+/*      Copyright (C) 2004 Garrett A. Kajmowicz
+	This file is part of the uClibc++ Library.
+	This library is free software; you can redistribute it and/or
+	modify it under the terms of the GNU Lesser General Public
+	License as published by the Free Software Foundation; either
+	version 2.1 of the License, or (at your option) any later version.
+
+	This library is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+	Lesser General Public License for more details.
+
+	You should have received a copy of the GNU Lesser General Public
+	License along with this library; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+#include <basic_definitions>
+#include <deque>
+#include <vector>
+#include <functional>
+
+#ifndef __HEADER_STD_QUEUE
+#define __HEADER_STD_QUEUE 1
+
+#pragma GCC visibility push(default)
+
+namespace std{
+	
+	template <class T, class Container = deque<T> > class _UCXXEXPORT queue{
+	protected:
+		Container c;
+	public:
+		typedef typename Container::value_type	value_type;
+		typedef typename Container::size_type	size_type;
+		typedef Container			container_type;
+
+		explicit queue(const Container& a = Container()) : c(a) {  }
+
+		bool empty() const		{ return c.empty(); }
+		size_type size()  const		{ return c.size(); }
+		value_type&       front()	{ return c.front(); }
+		const value_type& front() const	{ return c.front(); }
+		value_type&       back()	{ return c.back(); }
+		const value_type& back() const	{ return c.back(); }
+		void push(const value_type& x)	{ c.push_back(x); }
+		void pop()			{ c.pop_front(); }
+	};
+
+
+	template <class T, class Container> _UCXXEXPORT bool
+		operator==(const queue<T, Container>& x, const queue<T, Container>& y)
+	{
+		return (x.c == y.c);
+	}
+	template <class T, class Container> _UCXXEXPORT bool
+		operator< (const queue<T, Container>& x, const queue<T, Container>& y)
+	{
+		return (x.c < y.c);
+	}
+	template <class T, class Container> _UCXXEXPORT bool
+		operator!=(const queue<T, Container>& x, const queue<T, Container>& y)
+	{
+		return (x.c != y.c);
+	}
+	template <class T, class Container> _UCXXEXPORT bool
+		operator> (const queue<T, Container>& x, const queue<T, Container>& y)
+	{
+		return (x.c > y.c);
+	}
+	template <class T, class Container> _UCXXEXPORT bool
+		operator>=(const queue<T, Container>& x, const queue<T, Container>& y)
+	{
+		return (x.c >= y.c);
+	}
+	template <class T, class Container> _UCXXEXPORT bool
+		operator<=(const queue<T, Container>& x, const queue<T, Container>& y)
+	{
+		return (x.c <= y.c);
+	}
+
+
+	template <class T,
+		class Container = vector<T>,
+		class Compare = less<typename Container::value_type>
+	> class _UCXXEXPORT priority_queue {
+	protected:
+		Container c;
+		Compare comp;
+	public:
+		typedef typename Container::value_type	value_type;
+		typedef typename Container::size_type	size_type;
+		typedef Container			container_type;
+
+		explicit priority_queue(const Compare& x = Compare(), const Container& a = Container())
+			: c(a), comp(x) { make_heap(c.begin(), c.end(), comp) ; }
+		template <class InputIterator> priority_queue(InputIterator first,
+			InputIterator last,
+			const Compare& x = Compare(),
+			const Container& y= Container())
+		:  c(y), comp(c)
+		{ 
+			c.insert(c.end(), first, last);
+			make_heap(c.begin(), c.end(), comp);
+		 }
+
+		bool empty() const       { return c.empty(); }
+		size_type size()  const       { return c.size(); }
+		const value_type& top() const { return c.front(); }
+		void push(const value_type& x){
+			c.push_back(x);
+			push_heap(c.begin(), c.end(), comp);
+		}
+		void pop(){
+			pop_heap(c.begin(), c.end(), comp);
+			c.pop_back();
+		}
+	};
+
+}
+
+#pragma GCC visibility pop
+
+#endif
+
+

misc/uClibc++/include/cxx/set

@@ -0,0 +1,406 @@
+/*	Copyright (C) 2004 Garrett A. Kajmowicz
+	This file is part of the uClibc++ Library.
+
+	This library is free software; you can redistribute it and/or
+	modify it under the terms of the GNU Lesser General Public
+	License as published by the Free Software Foundation; either
+	version 2.1 of the License, or (at your option) any later version.
+
+	This library is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+	Lesser General Public License for more details.
+
+	You should have received a copy of the GNU Lesser General Public
+	License along with this library; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+
+
+#include<memory>
+#include<utility>
+#include<iterator>
+#include <deque>
+#include<functional>
+#include <associative_base>
+
+#ifndef __STD_HEADER_SET
+#define __STD_HEADER_SET
+
+#pragma GCC visibility push(default)
+
+namespace std{
+
+
+template<class Key, class Compare = less<Key>, class Allocator = allocator<Key> > class set;
+template<class Key, class Compare = less<Key>, class Allocator = allocator<Key> > class multiset;
+
+
+/* This is the implementation for the set container.  As noted above, it deviates
+ * from ISO spec by deriving from a base class in order to reduce code redundancy.
+ * More code could be reduced by convirting to virtual functions (thus allowing
+ * much of the erase and insert code to be duplicated), but that would deviate from
+ * the specifications too much to be worth the risk.
+ */
+
+
+//Implementation of set
+
+
+template<class Key, class Compare, class Allocator> class _UCXXEXPORT set
+	: public __single_associative<Key, Key, Compare, Allocator>
+{
+		//Default value of allocator does not meet C++ standard specs, but it works for this library
+		//Deal with it
+public:
+
+	typedef	__single_associative<Key, Key, Compare, Allocator>	base;
+	typedef typename base::key_type					key_type;
+	typedef typename base::value_type				value_type;
+	typedef typename base::key_compare				key_compare;
+	typedef typename base::allocator_type				allocator_type;
+	typedef typename base::reference				reference;
+	typedef typename base::const_reference				const_reference;
+	typedef typename base::iterator					iterator;
+	typedef typename base::const_iterator				const_iterator;
+	typedef typename base::size_type				size_type;
+	typedef typename base::difference_type				difference_type;
+	typedef typename base::pointer					pointer;
+	typedef typename base::const_pointer				const_pointer;
+	typedef typename base::reverse_iterator				reverse_iterator;
+	typedef typename base::const_reverse_iterator			const_reverse_iterator;
+
+//	using base::value_compare;
+
+	static const key_type v_t_k(const value_type v){
+		return v;
+	}
+
+	explicit set(const Compare& comp = Compare(), const Allocator& al = Allocator())
+		: base(comp, al, v_t_k) {  }
+
+	template <class InputIterator> set(InputIterator first, InputIterator last,
+		const Compare& comp = Compare(), const Allocator& al = Allocator())
+		: base(first, last, comp, al, v_t_k) {  }
+
+	set(const set<Key, Compare,Allocator>& x) : base(x) {  }
+	~set() {  }
+
+	using base::operator=;
+	using base::operator==;
+	using base::operator!=;
+
+	using base::insert;
+	using base::erase;
+
+	using base::begin;
+	using base::end;
+	using base::rbegin;
+	using base::rend;
+
+	using base::empty;
+	using base::size;
+	using base::max_size;
+
+
+	using base::find;
+	using base::count;
+	using base::lower_bound;
+	using base::upper_bound;
+	using base::equal_range;
+
+protected:
+
+};
+
+
+//Implementation of multiset
+
+
+template<class Key, class Compare, class Allocator> class _UCXXEXPORT multiset
+	: public __multi_associative<Key, Key, Compare, Allocator>
+{
+		//Default value of allocator does not meet C++ standard specs, but it works for this library
+		//Deal with it
+public:
+
+	typedef	__multi_associative<Key, Key, Compare, Allocator> 	base;
+	typedef typename base::key_type					key_type;
+	typedef typename base::value_type				value_type;
+	typedef typename base::key_compare				key_compare;
+	typedef typename base::allocator_type				allocator_type;
+	typedef typename base::reference				reference;
+	typedef typename base::const_reference				const_reference;
+	typedef typename base::iterator					iterator;
+	typedef typename base::const_iterator				const_iterator;
+	typedef typename base::size_type				size_type;
+	typedef typename base::difference_type				difference_type;
+	typedef typename base::pointer					pointer;
+	typedef typename base::const_pointer				const_pointer;
+	typedef typename base::reverse_iterator				reverse_iterator;
+	typedef typename base::const_reverse_iterator			const_reverse_iterator;
+
+	static const key_type v_t_k(const value_type v){
+		return v;
+	}
+
+	explicit multiset(const Compare& comp = Compare(), const Allocator& al = Allocator())
+		: base(comp, al, v_t_k) {  }
+
+	template <class InputIterator> multiset(InputIterator first, InputIterator last,
+		const Compare& comp = Compare(), const Allocator& al = Allocator())
+		: base(first, last, comp, al, v_t_k) {  }
+
+
+	multiset(const multiset<Key, Compare, Allocator>& x) : base(x) {  }
+	~multiset() {  }
+
+	using base::operator=;
+	using base::operator==;
+	using base::operator!=;
+
+	using base::insert;
+	using base::erase;
+
+	using base::begin;
+	using base::end;
+	using base::rbegin;
+	using base::rend;
+
+	using base::empty;
+	using base::size;
+	using base::max_size;
+
+	using base::find;
+	using base::count;
+	using base::lower_bound;
+	using base::upper_bound;
+	using base::equal_range;
+
+
+protected:
+
+};
+
+
+/* Non-member functions.  These are at the end because they are not associated with any
+   particular class.  These will be implemented as I figure out exactly what all of
+   them are supposed to do, and I have time.
+ */
+
+	template <class Key, class Compare, class Allocator> _UCXXEXPORT bool operator<
+		(const set<Key,Compare,Allocator>& x, const set<Key,Compare,Allocator>& y)
+	{
+		typename set<Key,Compare,Allocator>::const_iterator first1 = x.begin();
+		typename set<Key,Compare,Allocator>::const_iterator first2 = y.begin();
+		typename set<Key,Compare,Allocator>::const_iterator last1 = x.end();
+		typename set<Key,Compare,Allocator>::const_iterator last2 = y.end();
+
+		while(first1 != last1 && first2 != last2){
+			if( *first1 < *first2 ){
+				return true;
+			}
+			if( *first2 < *first1 ){
+				return false;
+			}
+			++first1;
+			++first2;
+		}
+		return first1==last1 && first2 != last2;
+	}
+
+	template <class Key, class Compare, class Allocator> _UCXXEXPORT bool operator>
+		(const set<Key,Compare,Allocator>& x, const set<Key,Compare,Allocator>& y)
+	{
+		typename set<Key,Compare,Allocator>::const_iterator first1 = x.begin();
+		typename set<Key,Compare,Allocator>::const_iterator first2 = y.begin();
+		typename set<Key,Compare,Allocator>::const_iterator last1 = x.end();
+		typename set<Key,Compare,Allocator>::const_iterator last2 = y.end();
+
+		while(first1 != last1 && first2 != last2){
+			if( *first1 > *first2 ){
+				return true;
+			}
+			if( *first2 > *first1 ){
+				return false;
+			}
+			++first1;
+			++first2;
+		}
+		return first1!=last1 && first2 == last2;
+	}
+
+	template <class Key, class Compare, class Allocator> _UCXXEXPORT bool operator>=
+		(const set<Key,Compare,Allocator>& x, const set<Key,Compare,Allocator>& y)
+	{
+		typename set<Key,Compare,Allocator>::const_iterator first1 = x.begin();
+		typename set<Key,Compare,Allocator>::const_iterator first2 = y.begin();
+		typename set<Key,Compare,Allocator>::const_iterator last1 = x.end();
+		typename set<Key,Compare,Allocator>::const_iterator last2 = y.end();
+
+		while(first1 != last1 && first2 != last2){
+			if( *first1 > *first2 ){
+				return true;
+			}
+			if( *first2 > *first1 ){
+				return false;
+			}
+			++first1;
+			++first2;
+		}
+		return first1!=last1;
+	}
+
+	template <class Key, class Compare, class Allocator> _UCXXEXPORT bool operator<=
+		(const set<Key,Compare,Allocator>& x, const set<Key,Compare,Allocator>& y)
+	{
+		typename set<Key,Compare,Allocator>::const_iterator first1 = x.begin();
+		typename set<Key,Compare,Allocator>::const_iterator first2 = y.begin();
+		typename set<Key,Compare,Allocator>::const_iterator last1 = x.end();
+		typename set<Key,Compare,Allocator>::const_iterator last2 = y.end();
+
+		while(first1 != last1 && first2 != last2){
+			if( *first1 < *first2 ){
+				return true;
+			}
+			if( *first2 < *first1 ){
+				return false;
+			}
+			++first1;
+			++first2;
+		}
+		return first2!=last2;
+	}
+	template <class Key, class Compare, class Allocator> _UCXXEXPORT void swap
+		(set<Key,Compare,Allocator>& x, set<Key,Compare,Allocator>& y)
+	{
+		x.swap(y);
+	}
+
+
+	template <class Key, class Compare, class Allocator> _UCXXEXPORT bool operator==
+		(const multiset<Key,Compare,Allocator>& x, const multiset<Key,Compare,Allocator>& y)
+	{
+		if(x.data == y.data){
+			return true;
+		}
+		return false;
+	}
+
+	template <class Key, class Compare, class Allocator> _UCXXEXPORT bool operator<
+		(const multiset<Key,Compare,Allocator>& x, const multiset<Key,Compare,Allocator>& y)
+	{
+		typename multiset<Key,Compare,Allocator>::const_iterator first1 = x.begin();
+		typename multiset<Key,Compare,Allocator>::const_iterator first2 = y.begin();
+		typename multiset<Key,Compare,Allocator>::const_iterator last1 = x.end();
+		typename multiset<Key,Compare,Allocator>::const_iterator last2 = y.end();
+
+		while(first1 != last1 && first2 != last2){
+			if( *first1 < *first2 ){
+				return true;
+			}
+			if( *first2 < *first1 ){
+				return false;
+			}
+			++first1;
+			++first2;
+		}
+		return first1==last1 && first2 != last2;
+	}
+
+	template <class Key, class Compare, class Allocator> _UCXXEXPORT bool operator!=
+		(const multiset<Key,Compare,Allocator>& x, const multiset<Key,Compare,Allocator>& y)
+	{
+		typename multiset<Key,Compare,Allocator>::const_iterator first1 = x.begin();
+		typename multiset<Key,Compare,Allocator>::const_iterator first2 = y.begin();
+		typename multiset<Key,Compare,Allocator>::const_iterator last1 = x.end();
+		typename multiset<Key,Compare,Allocator>::const_iterator last2 = y.end();
+
+		while(first1 != last1 && first2 != last2){
+			if( *first1 != *first2 ){
+				return true;
+			}
+			++first1;
+			++first2;
+		}
+		return first1!=last1 || first2 != last2;
+	}
+
+	template <class Key, class Compare, class Allocator> _UCXXEXPORT bool operator>
+		(const multiset<Key,Compare,Allocator>& x, const multiset<Key,Compare,Allocator>& y)
+	{
+		typename multiset<Key,Compare,Allocator>::const_iterator first1 = x.begin();
+		typename multiset<Key,Compare,Allocator>::const_iterator first2 = y.begin();
+		typename multiset<Key,Compare,Allocator>::const_iterator last1 = x.end();
+		typename multiset<Key,Compare,Allocator>::const_iterator last2 = y.end();
+
+		while(first1 != last1 && first2 != last2){
+			if( *first1 > *first2 ){
+				return true;
+			}
+			if( *first2 > *first1 ){
+				return false;
+			}
+			++first1;
+			++first2;
+		}
+		return first1!=last1 && first2 == last2;
+	}
+
+	template <class Key, class Compare, class Allocator> _UCXXEXPORT bool operator>=
+		(const multiset<Key,Compare,Allocator>& x, const multiset<Key,Compare,Allocator>& y)
+	{
+		typename multiset<Key,Compare,Allocator>::const_iterator first1 = x.begin();
+		typename multiset<Key,Compare,Allocator>::const_iterator first2 = y.begin();
+		typename multiset<Key,Compare,Allocator>::const_iterator last1 = x.end();
+		typename multiset<Key,Compare,Allocator>::const_iterator last2 = y.end();
+
+		while(first1 != last1 && first2 != last2){
+			if( *first1 > *first2 ){
+				return true;
+			}
+			if( *first2 > *first1 ){
+				return false;
+			}
+			++first1;
+			++first2;
+		}
+		return first1!=last1;
+	}
+
+	template <class Key, class Compare, class Allocator> _UCXXEXPORT bool operator<=
+		(const multiset<Key,Compare,Allocator>& x, const multiset<Key,Compare,Allocator>& y)
+	{
+		typename multiset<Key,Compare,Allocator>::const_iterator first1 = x.begin();
+		typename multiset<Key,Compare,Allocator>::const_iterator first2 = y.begin();
+		typename multiset<Key,Compare,Allocator>::const_iterator last1 = x.end();
+		typename multiset<Key,Compare,Allocator>::const_iterator last2 = y.end();
+
+		while(first1 != last1 && first2 != last2){
+			if( *first1 < *first2 ){
+				return true;
+			}
+			if( *first2 < *first1 ){
+				return false;
+			}
+			++first1;
+			++first2;
+		}
+		return first2!=last2;
+	}
+
+	template <class Key, class Compare, class Allocator> _UCXXEXPORT void swap
+		(multiset<Key,Compare,Allocator>& x, multiset<Key,Compare,Allocator>& y)
+	{
+		x.swap(y);
+	}
+
+
+
+}
+
+#pragma GCC visibility pop
+
+#endif
+

misc/uClibc++/include/cxx/sstream

@@ -0,0 +1,384 @@
+/*	Copyright (C) 2004 Garrett A. Kajmowicz
+
+	This file is part of the uClibc++ Library.
+
+	This library is free software; you can redistribute it and/or
+	modify it under the terms of the GNU Lesser General Public
+	License as published by the Free Software Foundation; either
+	version 2.1 of the License, or (at your option) any later version.
+
+	This library is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+	Lesser General Public License for more details.
+
+	You should have received a copy of the GNU Lesser General Public
+	License along with this library; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+#include <basic_definitions>
+
+#ifndef HEADER_STD_SSTREAM
+#define HEADER_STD_SSTREAM 1
+
+#include <iosfwd>
+#include <ios>
+#include <istream>
+#include <ostream>
+#include <iostream>
+#include <string>
+
+#pragma GCC visibility push(default)
+
+namespace std{
+
+	template <class charT, class traits, class Allocator>
+		class _UCXXEXPORT basic_stringbuf : public basic_streambuf<charT,traits>
+	{
+	public:
+		typedef charT char_type;
+		typedef typename traits::int_type int_type;
+		typedef typename traits::pos_type pos_type;
+		typedef typename traits::off_type off_type;
+		typedef typename Allocator::size_type size_type;
+
+		explicit _UCXXEXPORT basic_stringbuf(ios_base::openmode which = ios_base::in | ios_base::out)
+			: data(), ielement(0), oelement(0)
+		{
+			basic_streambuf<charT,traits>::openedFor = which;
+		}
+
+		explicit _UCXXEXPORT basic_stringbuf(const basic_string<charT,traits,Allocator>& str,
+			ios_base::openmode which = ios_base::in | ios_base::out)
+			: data(str), ielement(0), oelement(0)
+		{
+			if(which & ios_base::ate){
+				oelement = data.length();
+			}
+			basic_streambuf<charT,traits>::openedFor = which;
+		}
+
+		virtual _UCXXEXPORT ~basic_stringbuf() { }
+
+		_UCXXEXPORT basic_string<charT,traits,Allocator> str() const{
+			return data;
+		}
+
+		_UCXXEXPORT void str(const basic_string<charT,traits,Allocator>& s){
+			data = s;
+			ielement = 0;
+			if(basic_streambuf<charT,traits>::openedFor & ios_base::ate){
+				oelement = data.length();
+			}else{
+				oelement = 0;
+			}
+		}
+
+	protected:
+		virtual _UCXXEXPORT int sync(){
+			return 0;
+		}
+		virtual _UCXXEXPORT int_type underflow(){
+			if(ielement >= data.length()){
+				return traits::eof();
+			}
+			return traits::to_int_type(data[ielement]);
+		}
+
+		virtual _UCXXEXPORT int_type uflow(){
+			int_type retval = underflow();
+			if(retval != traits::eof()){
+				++ielement;
+			}
+			return retval;	
+		}
+
+		virtual _UCXXEXPORT int_type   pbackfail(int_type c = traits::eof()){
+			//Error possibilities
+			if(ielement == 0){
+				return traits::eof();
+			}
+			if(ielement > data.length()){
+				ielement = data.length();
+				return traits::eof();
+			}
+			//eof passed in
+			if(traits::eq_int_type(c,traits::eof())==true){
+				--ielement;
+				return traits::not_eof(c);
+			}
+			if(traits::eq(traits::to_char_type(c),data[ielement-1]) == true){
+				--ielement;
+				return c;
+			}
+			if(basic_streambuf<charT,traits>::openedFor & ios_base::out){
+				--ielement;
+				data[ielement] = c;
+				return c;
+			}
+			return traits::eof();
+		}
+
+		virtual _UCXXEXPORT int showmanyc(){
+			return data.length() - ielement;
+		}
+		virtual _UCXXEXPORT streamsize xsgetn(char_type* c, streamsize n){
+			streamsize i = 0;
+			while(ielement < data.length() && i < n ){
+				c[i] = data[ielement];
+				++i;
+				++ielement;
+			}
+			return i;
+		}
+
+		virtual _UCXXEXPORT int_type overflow (int_type c = traits::eof()){
+			//Nothing to do
+			if(traits::eq_int_type(c,traits::eof())){
+				return traits::not_eof(c);
+			}
+
+			//Actually add character, if possible
+			if(basic_streambuf<charT,traits>::openedFor & ios_base::out){
+				if(oelement >= data.length()){
+					data.push_back(c);
+				}else{
+					data[oelement] = c;
+				}
+				++oelement;
+				return c;
+			}
+			//Not possible
+			return traits::eof();
+		}
+
+		virtual _UCXXEXPORT basic_streambuf<charT,traits>* setbuf(charT*, streamsize){
+			//This function does nothing
+			return this;
+		}
+
+		virtual _UCXXEXPORT streamsize xsputn(const char_type* s, streamsize n){
+			data.replace(oelement, n, s, n);
+			oelement += n;
+			return n;
+		}
+
+		virtual _UCXXEXPORT pos_type seekoff(off_type off, ios_base::seekdir way,
+			ios_base::openmode which = ios_base::in | ios_base::out)
+		{
+			//Test for invalid option
+			if( (which & ios_base::in) && (which & ios_base::out) && (way == ios_base::cur)){
+				return -1;
+			}
+
+			//Calculate new location
+			size_type newpos = 0;
+
+			if(way == ios_base::beg){
+				newpos = off;
+			}else if(way == ios_base::cur){
+				if(which & ios_base::out){
+					newpos = data.length() + off;
+				}
+				if(which & ios_base::in){
+					newpos = ielement + off;
+				}
+				
+			}else{
+				newpos = data.length() + off;
+			}
+
+			//Test for error conditions
+			if(newpos > data.length()){
+				return -1;
+			}
+
+			//Shuffle pointers
+
+			if(which & ios_base::in){
+				ielement = newpos;
+			}
+			if(which & ios_base::out){
+				data.resize(newpos);
+				if(ielement > data.length()){
+					ielement = data.length();
+				}
+			}
+
+			return newpos;
+		}
+			
+		virtual _UCXXEXPORT pos_type seekpos(pos_type sp, 
+			ios_base::openmode which = ios_base::in | ios_base::out)
+		{
+			return seekoff(sp, ios_base::beg, which);
+		}
+
+		basic_string<charT,traits,Allocator> data;
+		size_type ielement;
+		size_type oelement;
+	};
+
+
+	template <class charT, class traits, class Allocator> class _UCXXEXPORT basic_istringstream
+		: public basic_istream<charT,traits>
+	{
+	public:
+		typedef charT char_type;
+		typedef typename traits::int_type int_type;
+		typedef typename traits::pos_type pos_type;
+		typedef typename traits::off_type off_type;
+
+
+		explicit _UCXXEXPORT basic_istringstream(ios_base::openmode m = ios_base::in) 
+			: basic_ios<charT, traits>(&sb), basic_istream<charT,traits>(&sb), sb(m)
+		{
+		}
+		explicit _UCXXEXPORT basic_istringstream( const basic_string<charT,traits,Allocator>& str, 
+			ios_base::openmode which = ios_base::in) 
+			: basic_ios<charT, traits>(&sb), basic_istream<charT,traits>(&sb), sb(str, which)
+		{
+		}
+		virtual _UCXXEXPORT ~basic_istringstream() {  }
+		_UCXXEXPORT basic_stringbuf<charT,traits,Allocator>* rdbuf() const{
+			return &sb;
+		}
+		_UCXXEXPORT basic_string<charT,traits,Allocator> str() const{
+			return sb.str();
+		}
+		_UCXXEXPORT void str(const basic_string<charT,traits,Allocator>& s){
+			sb.str(s);
+			basic_istream<charT,traits>::clear();
+		}
+	private:
+		basic_stringbuf<charT,traits,Allocator> sb;
+	};
+
+
+	template <class charT, class traits, class Allocator> class _UCXXEXPORT basic_ostringstream
+		: public basic_ostream<charT,traits>
+	{
+	public:
+
+		typedef charT char_type;
+		typedef typename traits::int_type int_type;
+		typedef typename traits::pos_type pos_type;
+		typedef typename traits::off_type off_type;
+
+		explicit _UCXXEXPORT basic_ostringstream(ios_base::openmode m = ios_base::out)
+			: basic_ios<charT, traits>(&sb), basic_ostream<charT,traits>(&sb), sb(m)
+		{
+		}
+		explicit _UCXXEXPORT basic_ostringstream(const basic_string<charT,traits,Allocator>& str, 
+			ios_base::openmode which = ios_base::out)
+			: basic_ios<charT, traits>(&sb), basic_ostream<charT,traits>(&sb), sb(str, which)
+		{
+		}
+		virtual _UCXXEXPORT ~basic_ostringstream() {  }
+
+		_UCXXEXPORT basic_stringbuf<charT,traits,Allocator>* rdbuf() const{
+			return &sb;
+		}
+		_UCXXEXPORT basic_string<charT,traits,Allocator> str() const{
+			return sb.str();
+		}
+		_UCXXEXPORT void str(const basic_string<charT,traits,Allocator>& s){
+			sb.str(s);
+			basic_ostream<charT,traits>::clear();
+		}
+	private:
+		basic_stringbuf<charT,traits,Allocator> sb;
+	};
+
+
+	template <class charT, class traits, class Allocator> class _UCXXEXPORT basic_stringstream
+		 : public basic_iostream<charT,traits>
+	{
+	public:
+
+		typedef charT char_type;
+		typedef typename traits::int_type int_type;
+		typedef typename traits::pos_type pos_type;
+		typedef typename traits::off_type off_type;
+
+		explicit _UCXXEXPORT basic_stringstream(ios_base::openmode which = ios_base::out|ios_base::in)
+			: basic_ios<charT, traits>(&sb), basic_iostream<charT,traits>(&sb), sb(which)
+		{
+		}
+
+		explicit _UCXXEXPORT basic_stringstream(const basic_string<charT,traits,Allocator>& str,
+			ios_base::openmode which = ios_base::out|ios_base::in)
+			: basic_ios<charT, traits>(&sb), basic_iostream<charT,traits>(&sb), sb(str, which)
+		{
+		}
+		virtual _UCXXEXPORT ~basic_stringstream(){  }
+
+		_UCXXEXPORT basic_stringbuf<charT,traits,Allocator>* rdbuf(){
+			return &sb;
+		}
+		_UCXXEXPORT basic_string<charT,traits,Allocator> str() const{
+			return sb.str();
+		}
+		_UCXXEXPORT void str(const basic_string<charT,traits,Allocator>& s){
+			sb.str(s);
+			basic_iostream<charT,traits>::clear();
+		}
+	private:
+		basic_stringbuf<charT, traits> sb;
+	};
+
+#ifdef __UCLIBCXX_EXPAND_SSTREAM_CHAR__
+#ifndef __UCLIBCXX_COMPILE_SSTREAM__
+
+#ifdef __UCLIBCXX_EXPAND_CONSTRUCTORS_DESTRUCTORS__
+
+	template <> _UCXXEXPORT basic_stringbuf<char, char_traits<char>, allocator<char> >::
+		basic_stringbuf(ios_base::openmode which);
+	template <> _UCXXEXPORT basic_stringbuf<char, char_traits<char>, allocator<char> >::~basic_stringbuf();
+
+#endif // __UCLIBCXX_EXPAND_CONSTRUCTORS_DESTRUCTORS__
+
+	template <> _UCXXEXPORT basic_string<char, char_traits<char>, allocator<char> >
+		basic_stringbuf<char, char_traits<char>, allocator<char> >::str() const;
+
+	template <> _UCXXEXPORT basic_stringbuf<char, char_traits<char>, allocator<char> >::int_type
+		basic_stringbuf<char, char_traits<char>, allocator<char> >::
+			pbackfail(basic_stringbuf<char, char_traits<char>, allocator<char> >::int_type c);
+
+	template <> _UCXXEXPORT basic_stringbuf<char, char_traits<char>, allocator<char> >::pos_type
+		basic_stringbuf<char, char_traits<char>, allocator<char> >::
+			seekoff (basic_stringbuf<char, char_traits<char>, allocator<char> >::off_type off,
+				ios_base::seekdir way,
+				ios_base::openmode which
+			);
+
+	template <> _UCXXEXPORT basic_stringbuf<char, char_traits<char>, allocator<char> >::int_type
+		basic_stringbuf<char, char_traits<char>, allocator<char> >::
+			overflow (basic_stringbuf<char, char_traits<char>, allocator<char> >::int_type c);
+
+	template <> _UCXXEXPORT basic_stringbuf<char, char_traits<char>, allocator<char> >::int_type
+		basic_stringbuf<char, char_traits<char>, allocator<char> >::underflow ();
+
+	template <> _UCXXEXPORT streamsize basic_stringbuf<char, char_traits<char>, allocator<char> >::
+		xsputn(const char* s, streamsize n);
+
+#ifdef __UCLIBCXX_EXPAND_CONSTRUCTORS_DESTRUCTORS__
+
+	template <> _UCXXEXPORT basic_stringstream<char, char_traits<char>, allocator<char> >::
+		basic_stringstream(ios_base::openmode which);
+	template <> _UCXXEXPORT basic_stringstream<char, char_traits<char>, allocator<char> >::~basic_stringstream();
+	template <> _UCXXEXPORT basic_istringstream<char, char_traits<char>, allocator<char> >::~basic_istringstream();
+	template <> _UCXXEXPORT basic_ostringstream<char, char_traits<char>, allocator<char> >::~basic_ostringstream();
+
+#endif //__UCLIBCXX_EXPAND_CONSTRUCTORS_DESTRUCTORS__
+
+#endif
+#endif
+
+#pragma GCC visibility pop
+
+}
+
+
+#endif

misc/uClibc++/include/cxx/stack

@@ -0,0 +1,84 @@
+/*      Copyright (C) 2004 Garrett A. Kajmowicz
+	This file is part of the uClibc++ Library.
+	This library is free software; you can redistribute it and/or
+	modify it under the terms of the GNU Lesser General Public
+	License as published by the Free Software Foundation; either
+	version 2.1 of the License, or (at your option) any later version.
+
+	This library is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+	Lesser General Public License for more details.
+
+	You should have received a copy of the GNU Lesser General Public
+	License along with this library; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+#include <basic_definitions>
+#include <deque>
+
+#ifndef __HEADER_STD_STACK
+#define __HEADER_STD_STACK 1
+
+#pragma GCC visibility push(default)
+
+namespace std{
+
+	template <class T, class Container = deque<T> > class _UCXXEXPORT stack{
+	protected:
+		Container c;
+
+	public:
+		typedef typename Container::value_type	value_type;
+		typedef typename Container::size_type	size_type;
+		typedef Container			container_type;
+
+		explicit stack(const Container& a = Container()) : c(a) {  };
+		bool empty() const { return c.empty(); }
+		size_type size() const { return c.size(); }
+		value_type&       top() { return c.back(); }
+		const value_type& top() const { return c.back(); }
+		void push(const value_type& x) { c.push_back(x); }
+		void pop() { c.pop_back(); }
+
+		bool operator==(const stack<T, Container> &x) const{
+			return  x.c == c;
+		}
+
+	};
+
+
+	template <class T, class Container> _UCXXEXPORT bool
+		operator< (const stack<T, Container>& x, const stack<T, Container>& y)
+	{
+		return (x.c < y.c);
+	}
+	template <class T, class Container> _UCXXEXPORT bool
+		operator!=(const stack<T, Container>& x, const stack<T, Container>& y)
+	{
+		return (x.c != y.c);
+	}
+	template <class T, class Container> _UCXXEXPORT bool
+		operator> (const stack<T, Container>& x, const stack<T, Container>& y)
+	{
+		return (x.c > y.c);
+	}
+	template <class T, class Container> _UCXXEXPORT bool
+		operator>=(const stack<T, Container>& x, const stack<T, Container>& y)
+	{
+		return (x.c >= y.c);
+	}
+	template <class T, class Container> _UCXXEXPORT bool
+		operator<=(const stack<T, Container>& x, const stack<T, Container>& y)
+	{
+		return (x.c <= y.c);
+	}
+
+}
+
+#pragma GCC visibility pop
+
+#endif
+
+

misc/uClibc++/include/cxx/stdexcept

@@ -0,0 +1,117 @@
+/*	Copyright (C) 2004 Garrett A. Kajmowicz
+
+	This file is part of the uClibc++ Library.
+
+	This library is free software; you can redistribute it and/or
+	modify it under the terms of the GNU Lesser General Public
+	License as published by the Free Software Foundation; either
+	version 2.1 of the License, or (at your option) any later version.
+
+	This library is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+	Lesser General Public License for more details.
+
+	You should have received a copy of the GNU Lesser General Public
+	License along with this library; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+#include <basic_definitions>
+#include <exception>
+#include <string>
+
+#ifndef HEADER_STD_EXCEPTIONS
+#define HEADER_STD_EXCEPTIONS 1
+
+//Don't include support if not needed
+#ifdef __UCLIBCXX_EXCEPTION_SUPPORT__
+
+#pragma GCC visibility push(default)
+
+namespace std{
+
+//typedef basic_string<char> string;
+
+class _UCXXEXPORT logic_error : public exception {
+protected:
+	string mstring;
+public:
+	logic_error() throw();
+	logic_error(const string& what_arg);
+
+	virtual ~logic_error() throw() {}
+	virtual const char * what() const throw();
+
+};	
+
+class _UCXXEXPORT domain_error : public logic_error {
+public:
+	domain_error() : logic_error() {}
+	domain_error(const string& what_arg) : logic_error(what_arg) {}
+	virtual ~domain_error() throw() {}
+};
+
+class _UCXXEXPORT invalid_argument : public logic_error {
+public:
+	invalid_argument() : logic_error(){}
+	invalid_argument(const string& what_arg) : logic_error(what_arg){}
+	virtual ~invalid_argument() throw() {}
+};
+
+class _UCXXEXPORT length_error : public logic_error {
+public:
+	length_error() : logic_error(){}
+	length_error(const string& what_arg) : logic_error(what_arg){}
+	virtual ~length_error() throw() {}
+};
+
+class _UCXXEXPORT out_of_range : public logic_error{
+public:
+	out_of_range();
+	out_of_range(const string & what_arg);
+	virtual ~out_of_range() throw() {}
+
+};
+
+class _UCXXEXPORT runtime_error : public exception{
+protected:
+	string mstring;
+public:
+	runtime_error();
+	runtime_error(const string& what_arg);
+
+	virtual ~runtime_error() throw() {}
+	virtual const char * what() const throw();
+};
+
+class _UCXXEXPORT range_error : public runtime_error{
+public:
+	range_error() : runtime_error(){}
+	range_error(const string& what_arg) : runtime_error(what_arg) {}
+	virtual ~range_error() throw(){ }
+};
+
+
+class _UCXXEXPORT overflow_error : public runtime_error{
+public:
+	overflow_error() : runtime_error(){}
+	overflow_error(const string& what_arg) : runtime_error(what_arg) {}
+	virtual ~overflow_error() throw(){}
+};
+
+class _UCXXEXPORT underflow_error : public runtime_error{
+public:
+	underflow_error() : runtime_error(){}
+	underflow_error(const string& what_arg) : runtime_error(what_arg) {}
+	virtual ~underflow_error() throw(){}
+};
+
+
+
+}
+
+#pragma GCC visibility pop
+
+#endif
+#endif

misc/uClibc++/include/cxx/streambuf

@@ -0,0 +1,329 @@
+/*	Copyright (C) 2004 Garrett A. Kajmowicz
+
+	This file is part of the uClibc++ Library.
+
+	This library is free software; you can redistribute it and/or
+	modify it under the terms of the GNU Lesser General Public
+	License as published by the Free Software Foundation; either
+	version 2.1 of the License, or (at your option) any later version.
+
+	This library is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+	Lesser General Public License for more details.
+
+	You should have received a copy of the GNU Lesser General Public
+	License along with this library; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+#include <basic_definitions>
+#include <locale>
+#include <string>
+#include <iosfwd>
+
+#ifndef HEADER_STD_STREAMBUF
+#define HEADER_STD_STREAMBUF 1
+
+#include <ios>
+
+#pragma GCC visibility push(default)
+
+namespace std{
+
+	template <class charT, class traits> class _UCXXEXPORT basic_streambuf{
+	public:
+#ifdef __UCLIBCXX_SUPPORT_CDIR__
+		friend ios_base::Init::Init();
+#endif
+	// Types:
+		typedef charT				char_type;
+		typedef typename traits::int_type	int_type;
+		typedef typename traits::pos_type	pos_type;
+		typedef typename traits::off_type	off_type;
+		typedef traits				traits_type;
+
+		virtual ~basic_streambuf();
+
+		locale pubimbue(const locale &loc);
+
+		locale getloc() const{
+			return myLocale;
+		}
+
+		basic_streambuf<char_type,traits>* pubsetbuf(char_type* s, streamsize n){
+			return setbuf(s,n);
+		}
+		pos_type pubseekoff(off_type off, 
+			typename ios_base::seekdir way, 
+			ios_base::openmode which = ios_base::in |
+			ios_base::out
+			)
+		{
+			return seekoff(off,way,which);
+		}
+		pos_type pubseekpos(pos_type sp, ios_base::openmode which = ios_base::in | ios_base::out){
+			return seekpos(sp,which);
+		}
+		int pubsync(){
+			return sync();
+		}
+
+		streamsize in_avail();
+
+		int_type snextc();
+
+		int_type sbumpc();
+
+		int_type sgetc();
+
+		streamsize sgetn(char_type* s, streamsize n){
+			return xsgetn(s,n);
+		}
+
+		int_type sputbackc(char_type c);
+
+		int_type sungetc();
+
+		int_type sputc(char_type c);
+
+		streamsize sputn(const char_type* s, streamsize n){
+			if(openedFor & ios_base::app){
+				seekoff(0, ios_base::end, ios_base::out);
+			}
+			return xsputn(s, n);
+		}
+
+	protected:
+		locale myLocale;
+		//Pointers for the "get" buffers
+		charT * mgbeg;
+		charT * mgnext;
+		charT * mgend;
+
+		//Pointers for the "put" buffers	
+		charT * mpbeg;
+		charT * mpnext;
+		charT * mpend;
+
+		//In the event of null buffers Lets us know what the buffer is opened for
+		ios_base::openmode openedFor;
+		
+		basic_streambuf();
+
+		basic_streambuf(const basic_streambuf<char, char_traits<char> > &)
+			: myLocale(),
+			mgbeg(0), mgnext(0), mgend(0), mpbeg(0), mpnext(0), mpend(0),
+			openedFor(0)
+		{ }
+		basic_streambuf<char, char_traits<char> > & operator=(const basic_streambuf<char, char_traits<char> > &){
+			return *this;
+		}
+		
+		char_type* eback() const{
+			return mgbeg;
+		}
+		char_type* gptr()  const{
+			return mgnext;
+		}
+		char_type* egptr() const{
+			return mgend;
+		}
+		void gbump(int n){
+			mgnext+=n;
+		}
+		void setg(char_type* gbeg, char_type* gnext, char_type* gend){
+			mgbeg = gbeg;
+			mgnext = gnext;
+			mgend = gend;
+		}
+
+		char_type* pbase() const{
+			return mpbeg;
+		}
+		char_type* pptr() const{
+			return mpnext;
+		}
+		char_type* epptr() const{
+			return mpend;
+		}
+		void pbump(int n){
+			mpnext+=n;
+		}
+		void setp(char_type* pbeg, char_type* pend){
+			mpbeg = pbeg;
+			mpnext  = pbeg;
+			mpend = pend;
+		}
+
+		virtual void imbue(const locale &loc){
+			myLocale = loc;
+		}
+
+		//Virtual functions which we will not implement
+
+		virtual basic_streambuf<char_type,traits>* setbuf(char_type* , streamsize){
+			return 0;
+		}
+		virtual pos_type seekoff(off_type , ios_base::seekdir, 
+			ios_base::openmode = ios_base::in | ios_base::out)
+		{
+			return 0;
+		}
+		virtual pos_type seekpos(pos_type , ios_base::openmode = ios_base::in | ios_base::out){
+			return 0;
+		}
+		virtual int sync(){
+			return 0;
+		}
+
+		virtual int showmanyc(){
+			return 0;
+		}
+		virtual streamsize xsgetn(char_type* , streamsize ){
+			return 0;
+		}
+		virtual int_type underflow(){
+			return traits_type::eof();
+		}
+		virtual int_type uflow(){
+			int_type ret = underflow();
+			if (!traits_type::eq_int_type(ret, traits_type::eof()))
+				gbump(1);
+			return ret;
+		}
+
+		virtual int_type pbackfail(int_type c = traits::eof()){
+			return c;
+		}
+		virtual streamsize xsputn(const char_type* c, streamsize n){
+			//This function is designed to be replaced by subclasses
+			for(streamsize i = 0; i< n; ++i){
+				if(sputc(c[i]) == traits::eof()){
+					return i;
+				}
+			}
+			return n;
+		}
+		virtual int_type overflow (int_type c = traits::eof()){
+			return c;
+		}
+	};
+
+	typedef basic_streambuf<char>     streambuf;
+#ifdef __UCLIBCXX_HAS_WCHAR__
+	typedef basic_streambuf<wchar_t> wstreambuf;
+#endif
+
+
+//Definitions put below to allow for easy expansion of code
+
+	template <class C, class T> basic_streambuf<C, T>::~basic_streambuf(){  }
+
+	template <class C, class T> locale basic_streambuf<C, T>::pubimbue(const locale &loc){
+		locale temp = myLocale;
+		myLocale = loc;
+		return temp;
+	}
+
+	template <class C, class T> streamsize basic_streambuf<C, T>::in_avail(){
+		if(mgend !=0 && mgnext !=0){
+			return mgend - mgnext;
+		}
+		return showmanyc();
+	}
+
+	template <class C, class T> typename basic_streambuf<C, T>::int_type basic_streambuf<C, T>::sbumpc(){
+		if(mgbeg == 0 || mgnext == mgend){
+			return uflow();
+		}
+		int_type retval = T::to_int_type(*gptr());
+		gbump(1);
+		return retval;
+	}
+
+	template <class C, class T> typename basic_streambuf<C, T>::int_type basic_streambuf<C, T>::snextc(){
+		if(sbumpc() == T::eof() ){
+			return T::eof() ;
+		}
+		return sgetc();
+	}
+
+	template <class C, class T> typename basic_streambuf<C, T>::int_type basic_streambuf<C, T>::sgetc(){
+		if(mgbeg == 0 || mgnext == mgend){
+			return underflow();
+		}
+		return T::to_int_type(*gptr());
+	}
+
+	template <class C, class T> typename basic_streambuf<C, T>::int_type basic_streambuf<C, T>::sputbackc(char_type c){
+		if(mgbeg == 0 || mgnext == mgbeg || !T::eq(c, gptr()[-1] )){
+			return pbackfail(T::to_int_type(c));
+		}
+		gbump(-1);
+		return T::to_int_type(*gptr());
+	}
+
+	template <class C, class T> typename basic_streambuf<C, T>::int_type basic_streambuf<C, T>::sungetc(){
+		if(mgbeg == 0 || mgnext == mgbeg){
+			return ios_base::failbit;
+		}
+		gbump(-1);
+		return T::to_int_type(*gptr());
+	}
+
+	template <class C, class T> typename basic_streambuf<C, T>::int_type basic_streambuf<C, T>::sputc(char_type c){
+		if(openedFor & ios_base::app){
+			seekoff(0, ios_base::end, ios_base::out);
+		}
+		if(mpnext < mpend){
+			*mpnext = c;
+			++mpnext;
+		}else{
+			return overflow( T::to_int_type(c) );
+		}
+		return T::to_int_type(c);
+	}
+
+	template <class C, class T> basic_streambuf<C, T>::basic_streambuf() 
+		: myLocale(),
+		mgbeg(0), mgnext(0), mgend(0), mpbeg(0), mpnext(0), mpend(0),
+		openedFor(0)
+	{ }
+
+
+
+
+
+
+#ifdef __UCLIBCXX_EXPAND_STREAMBUF_CHAR__
+#ifndef __UCLIBCXX_COMPILE_STREAMBUF__
+
+#ifdef __UCLIBCXX_EXPAND_CONSTRUCTORS_DESTRUCTORS__
+
+	template <> _UCXXEXPORT streambuf::basic_streambuf();
+	template <> _UCXXEXPORT streambuf::~basic_streambuf();
+
+#endif //__UCLIBCXX_EXPAND_CONSTRUCTORS_DESTRUCTORS__
+
+	template <> _UCXXEXPORT locale streambuf::pubimbue(const locale &loc);
+	template <> _UCXXEXPORT streamsize streambuf::in_avail();
+	template <> _UCXXEXPORT streambuf::int_type streambuf::sbumpc();
+	template <> _UCXXEXPORT streambuf::int_type streambuf::snextc();
+	template <> _UCXXEXPORT streambuf::int_type streambuf::sgetc();
+	template <> _UCXXEXPORT streambuf::int_type streambuf::sputbackc(char_type c);
+	template <> _UCXXEXPORT streambuf::int_type streambuf::sungetc();
+	template <> _UCXXEXPORT streambuf::int_type streambuf::sputc(char_type c);
+
+#endif
+#endif
+
+
+
+
+
+}
+
+#pragma GCC visibility pop
+
+#endif

misc/uClibc++/include/cxx/string_iostream

@@ -0,0 +1,146 @@
+/*	Copyright (C) 2004 Garrett A. Kajmowicz
+
+	This file is part of the uClibc++ Library.
+
+	This library is free software; you can redistribute it and/or
+	modify it under the terms of the GNU Lesser General Public
+	License as published by the Free Software Foundation; either
+	version 2.1 of the License, or (at your option) any later version.
+
+	This library is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+	Lesser General Public License for more details.
+
+	You should have received a copy of the GNU Lesser General Public
+	License along with this library; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+#include <istream>
+#include <ostream>
+#include <string>
+
+#ifdef __UCLIBCXX_HAS_WCHAR__
+#include <cwchar>
+#include <cwctype>
+#endif
+
+#ifndef __HEADER_STD_STRING_IOSTREAM
+#define __HEADER_STD_STRING_IOSTREAM 1
+
+#pragma GCC visibility push(default)
+
+namespace std{
+
+
+
+template<class charT, class traits, class Allocator> _UCXXEXPORT basic_ostream<charT, traits>&
+	operator<<(basic_ostream<charT, traits>& os, const basic_string<charT,traits,Allocator>& str)
+{
+	return os.write(str.data(), str.length());
+}
+
+template<class charT, class traits, class Allocator> _UCXXEXPORT basic_istream<charT,traits>&
+	operator>>(basic_istream<charT,traits>& is, basic_string<charT,traits,Allocator>& str)
+{
+
+	typename basic_istream<charT, traits>::sentry s(is);
+	if(s == false){
+		return is;
+	}
+
+	str.clear();
+
+	typename basic_istream<charT, traits>::int_type c;
+	typename Allocator::size_type n = is.width();
+	bool exitnow = false;
+	if(n == 0){
+		n = str.max_size();
+	}
+
+//	//Clear out preliminary spaces first
+//	c = is.get();
+//	while(isspace(c)){
+//		c = is.get();
+//	}
+//
+//	is.putback(c);
+
+	do{
+		c = is.get();
+		if(c == traits::eof() || isspace(c) || n == 0){
+			is.putback(c);
+			exitnow = true;
+		}else{
+			str.append(1, traits::to_char_type(c) );
+			--n;
+		}
+	}while(exitnow == false);
+	return is;
+}
+
+template<class charT, class traits, class Allocator> _UCXXEXPORT basic_istream<charT,traits>&
+	getline(basic_istream<charT,traits>& is, basic_string<charT,traits,Allocator>& str, charT delim)
+{
+	typename basic_istream<charT,traits>::sentry s(is);
+	if(s == false){
+		return is;
+	}
+
+	str.erase();
+
+	streamsize i = 0;
+	typename basic_istream<charT,traits>::int_type c_i;
+	charT c;
+	unsigned int n = str.max_size();
+	for(i=0;i<n;++i){
+		c_i=is.get();
+		if(c_i == traits::eof() ){
+			return is;
+		}
+		c = traits::to_char_type(c_i);
+		if(c == delim){
+			return is;
+		}
+		str.append(1, c);
+	}
+	return is;	
+}
+
+template<class charT, class traits, class Allocator> _UCXXEXPORT basic_istream<charT,traits>&
+	getline(basic_istream<charT,traits>& is, basic_string<charT,traits,Allocator>& str)
+{
+	return getline(is, str, '\n');
+}
+
+
+#ifdef __UCLIBCXX_EXPAND_STRING_CHAR__
+#ifndef __UCLIBCXX_COMPILE_STRING__
+
+
+#ifdef __UCLIBCXX_EXPAND_ISTREAM_CHAR__
+template<> _UCXXEXPORT basic_istream<char, char_traits<char> >& operator>>(
+	basic_istream<char,char_traits<char> >& is,
+	basic_string<char, char_traits<char>, allocator<char> >& str);
+#endif
+
+
+#ifdef __UCLIBCXX_EXPAND_OSTREAM_CHAR__
+template<> _UCXXEXPORT basic_ostream<char, char_traits<char> >&
+	operator<<(basic_ostream<char, char_traits<char> >& os, 
+	const basic_string<char,char_traits<char>, std::allocator<char> >& str);
+
+#endif
+
+
+#endif
+#endif
+
+
+}
+
+#pragma GCC visibility pop
+
+#endif
+

misc/uClibc++/include/cxx/support

@@ -0,0 +1,165 @@
+/*	Copyright (C) 2004 Garrett A. Kajmowicz
+
+	This file is part of the uClibc++ Library.
+
+	This library is free software; you can redistribute it and/or
+	modify it under the terms of the GNU Lesser General Public
+	License as published by the Free Software Foundation; either
+	version 2.1 of the License, or (at your option) any later version.
+
+	This library is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+	Lesser General Public License for more details.
+
+	You should have received a copy of the GNU Lesser General Public
+	License along with this library; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+#include <exception>
+#include <cstdlib>
+#include <typeinfo>
+
+#ifndef HEADER_ULC_SUPPORT
+#define HEADER_ULC_SUPPORT 1
+
+using namespace std;
+
+//From C++ ABI spec
+typedef enum {
+	_URC_NO_REASON = 0,
+	_URC_FOREIGN_EXCEPTION_CAUGHT = 1,
+	_URC_FATAL_PHASE2_ERROR = 2,
+	_URC_FATAL_PHASE1_ERROR = 3,
+	_URC_NORMAL_STOP = 4,
+	_URC_END_OF_STACK = 5,
+	_URC_HANDLER_FOUND = 6,
+	_URC_INSTALL_CONTEXT = 7,
+	_URC_CONTINUE_UNWIND = 8
+} _Unwind_Reason_Code;
+
+
+typedef void (*_Unwind_Exception_Cleanup_Fn)
+	(_Unwind_Reason_Code reason, struct _Unwind_Exception *exc);
+
+//The following definitions were grabbed from the gcc implementation
+typedef unsigned _Unwind_Ptr __attribute__((__mode__(__pointer__)));
+typedef unsigned _Unwind_Word __attribute__((__mode__(__word__)));
+typedef signed _Unwind_Sword __attribute__((__mode__(__word__)));
+typedef unsigned _Unwind_Exception_Class __attribute__((__mode__(__DI__)));
+typedef void (*_Unwind_Exception_Cleanup_Fn) (_Unwind_Reason_Code, struct _Unwind_Exception *);
+
+typedef int _Unwind_Action;
+static const _Unwind_Action _UA_SEARCH_PHASE = 1;
+static const _Unwind_Action _UA_CLEANUP_PHASE = 2;
+static const _Unwind_Action _UA_HANDLER_FRAME = 4;
+static const _Unwind_Action _UA_FORCE_UNWIND = 8;
+
+const _Unwind_Exception_Class __uclibcxx_exception_class = ((((((((
+	_Unwind_Exception_Class) 'u' << 8 | (_Unwind_Exception_Class) 'l') << 8
+	| (_Unwind_Exception_Class) 'i') << 8 | (_Unwind_Exception_Class) 'b') << 8
+	| (_Unwind_Exception_Class) 'C')<< 8 | (_Unwind_Exception_Class) '+') << 8
+	| (_Unwind_Exception_Class) '+') << 8 | (_Unwind_Exception_Class) '\0');
+
+
+#define _UA_SEARCH_PHASE        1
+#define _UA_CLEANUP_PHASE       2
+#define _UA_HANDLER_FRAME       4
+#define _UA_FORCE_UNWIND        8
+#define _UA_END_OF_STACK        16
+
+struct _Unwind_Exception{
+        _Unwind_Exception_Class exception_class;		//Type of exception, eg ulibC++\0
+        _Unwind_Exception_Cleanup_Fn exception_cleanup;		//Destructor if from diff runtime
+        _Unwind_Word private_1;					//Don't touch at all!
+        _Unwind_Word private_2;					//Don't touch at all!
+} __attribute__((__aligned__));
+
+
+//The following structure is system-dependent and defined by the compiler
+//Thus it's definition was copied from the gcc 3.4.0 header files
+struct _Unwind_Context;
+//{
+//	void *reg[DWARF_FRAME_REGISTERS+1];
+//	void *cfa;
+//	void *ra;
+//	void *lsda;
+//	struct dwarf_eh_bases bases;
+//	_Unwind_Word args_size;
+//};
+
+
+
+_Unwind_Reason_Code _Unwind_RaiseException ( struct _Unwind_Exception *exception_object );
+
+//_Unwind_ForcedUnwind
+
+typedef _Unwind_Reason_Code (*_Unwind_Stop_Fn)
+	(int version, _Unwind_Action actions,  _Unwind_Exception_Class exceptionClass,
+	struct _Unwind_Exception *exceptionObject,
+	struct _Unwind_Context *context, void *stop_parameter );
+
+_Unwind_Reason_Code _Unwind_ForcedUnwind (
+	struct _Unwind_Exception *exception_object, _Unwind_Stop_Fn stop,
+	void *stop_parameter );
+
+void _Unwind_Resume (struct _Unwind_Exception *exception_object);
+void _Unwind_DeleteException (struct _Unwind_Exception *exception_object);
+
+_Unwind_Word _Unwind_GetGR (struct _Unwind_Context *context, int index);
+void _Unwind_SetGR (struct _Unwind_Context *context, int index, _Unwind_Word);
+
+_Unwind_Ptr _Unwind_GetIP (struct _Unwind_Context *context);
+void _Unwind_SetIP (struct _Unwind_Context *context, _Unwind_Ptr new_value);
+
+_Unwind_Ptr _Unwind_GetLanguageSpecificData (struct _Unwind_Context *context);
+_Unwind_Ptr _Unwind_GetRegionStart (struct _Unwind_Context *context);
+
+_Unwind_Reason_Code (*__personality_routine)
+	(int version,					//Should be 1
+	_Unwind_Action actions,				//Actions the routine will perform (bitmask)
+	_Unwind_Exception_Class exceptionClass,		//Type of exception - vendor is high 4 bytes
+	struct _Unwind_Exception *exceptionObject,	//Points to exception header
+	struct _Unwind_Context *context);		//Unwinder state information
+
+
+/*The following part is the Level II ABI which is required for compatability*/
+//This might be the only stuff that *I* need to implement
+
+struct __cxa_exception {
+	std::type_info *exceptionType;		//Type of thrown exception
+	void (*exceptionDestructor) (void *);	//Pointer to the destructor
+	unexpected_handler unexpectedHandler;	//Unexpected handler to use
+	terminate_handler terminateHandler;	//Terminate handle to use
+	__cxa_exception *nextException;		//per thread linked list
+
+	int handlerCount;			//How many handlers have caught this
+	int handlerSwitchValue;
+	const char *actionRecord;
+	const char *languageSpecificData;
+	void *catchTemp;
+	void *adjustedPtr;
+
+	_Unwind_Exception unwindHeader;
+};
+
+struct __cxa_eh_globals {
+	__cxa_exception *caughtExceptions;
+	unsigned int uncaughtExceptions;
+};
+
+extern "C" __cxa_eh_globals *__cxa_get_globals(void);	//Return ptr to the eh_globals object for current thread
+extern "C" __cxa_eh_globals *__cxa_get_globals_fast(void);	//Same as above, assumes that above called at least once
+
+extern "C" void *__cxa_allocate_exception(size_t thrown_size);	//Allocate space for exception plus header
+extern "C" void __cxa_free_exception(void *thrown_exception);	//Free space allocated from the above
+
+extern "C" void __cxa_throw (void *thrown_exception,	//This is the actual throw call
+//	std::type_info *tinfo,			//Type of object
+	void * tinfo,			//Type of object
+	void (*dest) (void *) );		//Pointer to destructor destroy object
+
+
+#endif
+

misc/uClibc++/include/cxx/system_configuration.h

@@ -0,0 +1,48 @@
+/*
+ * Automatically generated C config: don't edit
+ */
+/*
+ * Version Number
+ */
+#define __UCLIBCXX_MAJOR__ 0
+#define __UCLIBCXX_MINOR__ 2
+#define __UCLIBCXX_SUBLEVEL__ 4
+
+/*
+ * Target Features and Options
+ */
+#define __UCLIBCXX_HAS_FLOATS__ 1
+#define __UCLIBCXX_HAS_LONG_DOUBLE__ 1
+#define __UCLIBCXX_HAS_TLS__ 1
+#define __WARNINGS__ "-Wall"
+#define __BUILD_EXTRA_LIBRARIES__ ""
+#define __HAVE_DOT_CONFIG__ 1
+
+/*
+ * String and I/O Stream Support
+ */
+#undef __UCLIBCXX_HAS_WCHAR__
+#define __UCLIBCXX_IOSTREAM_BUFSIZE__ 32
+#define __UCLIBCXX_HAS_LFS__ 1
+#define __UCLIBCXX_SUPPORT_CDIR__ 1
+#define __UCLIBCXX_SUPPORT_CIN__ 1
+#define __UCLIBCXX_SUPPORT_COUT__ 1
+#define __UCLIBCXX_SUPPORT_CERR__ 1
+#undef __UCLIBCXX_SUPPORT_CLOG__
+
+/*
+ * STL and Code Expansion
+ */
+#define __UCLIBCXX_STL_BUFFER_SIZE__ 32
+#define __UCLIBCXX_CODE_EXPANSION__ 1
+#define __UCLIBCXX_EXPAND_CONSTRUCTORS_DESTRUCTORS__ 1
+#define __UCLIBCXX_EXPAND_STRING_CHAR__ 1
+#define __UCLIBCXX_EXPAND_VECTOR_BASIC__ 1
+#define __UCLIBCXX_EXPAND_IOS_CHAR__ 1
+#define __UCLIBCXX_EXPAND_STREAMBUF_CHAR__ 1
+#define __UCLIBCXX_EXPAND_ISTREAM_CHAR__ 1
+#define __UCLIBCXX_EXPAND_OSTREAM_CHAR__ 1
+#define __UCLIBCXX_EXPAND_FSTREAM_CHAR__ 1
+#define __UCLIBCXX_EXPAND_SSTREAM_CHAR__ 1
+
+

misc/uClibc++/include/cxx/type_traits

@@ -0,0 +1,92 @@
+/*	Copyright (C) 2005 Garrett A. Kajmowicz
+
+	This file is part of the uClibc++ Library.
+	This library is free software; you can redistribute it and/or
+	modify it under the terms of the GNU Lesser General Public
+	License as published by the Free Software Foundation; either
+	version 2.1 of the License, or (at your option) any later version.
+
+	This library is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+	Lesser General Public License for more details.
+
+	You should have received a copy of the GNU Lesser General Public
+	License along with this library; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+#include <basic_definitions>
+#include <string.h>
+#include <exception>
+#include <memory>
+#include <char_traits>
+
+#ifndef __HEADER_TYPE_TRAITS
+#define __HEADER_TYPE_TRAITS 1
+
+#pragma GCC visibility push(default)
+
+namespace std{
+
+	struct _UCXXEXPORT __true_type{};
+	struct _UCXXEXPORT __false_type{};
+
+	template <class I> class _UCXXEXPORT __is_integer{
+	public:
+		typedef __false_type value;
+	};
+
+	template <> class _UCXXEXPORT __is_integer <unsigned int>{
+	public:
+		typedef __true_type value;
+	};
+
+	template <> class _UCXXEXPORT __is_integer <signed int>{
+	public:
+		typedef __true_type value;
+	};
+
+	template <> class _UCXXEXPORT __is_integer <short unsigned int>{
+	public:
+		typedef __true_type value;
+	};
+
+	template <> class _UCXXEXPORT __is_integer <short signed int>{
+	public:
+		typedef __true_type value;
+	};
+
+	template <> class _UCXXEXPORT __is_integer <char>{
+	public:
+		typedef __true_type value;
+	};
+
+	template <> class _UCXXEXPORT __is_integer <signed char>{
+	public:
+		typedef __true_type value;
+	};
+
+	template <> class _UCXXEXPORT __is_integer <unsigned char>{
+	public:
+		typedef __true_type value;
+	};
+
+	template <> class _UCXXEXPORT __is_integer <long unsigned int>{
+	public:
+		typedef __true_type value;
+	};
+
+	template <> class _UCXXEXPORT __is_integer <long signed int>{
+	public:
+		typedef __true_type value;
+	};
+
+
+
+}
+
+#pragma GCC visibility pop
+
+#endif
+

misc/uClibc++/include/cxx/typeinfo

@@ -0,0 +1,156 @@
+// RTTI support for -*- C++ -*-
+// Copyright (C) 1994, 1995, 1996, 1997, 1998, 2000, 2001, 2002
+// Free Software Foundation
+//
+// This file is part of GNU CC.
+//
+// GNU CC is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2, or (at your option)
+// any later version.
+// 
+// GNU CC is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+// 
+// You should have received a copy of the GNU General Public License
+// along with GNU CC; see the file COPYING.  If not, write to
+// the Free Software Foundation, 59 Temple Place - Suite 330,
+// Boston, MA 02111-1307, USA.
+
+// As a special exception, you may use this file as part of a free software
+// library without restriction.  Specifically, if other files instantiate
+// templates or use macros or inline functions from this file, or you compile
+// this file and link it with other files to produce an executable, this
+// file does not by itself cause the resulting executable to be covered by
+// the GNU General Public License.  This exception does not however
+// invalidate any other reasons why the executable file might be covered by
+// the GNU General Public License.
+
+/** @file typeinfo
+ *  This header provides RTTI support.
+ */
+
+#ifndef __TYPEINFO__
+#define __TYPEINFO__
+
+#include <exception>
+
+extern "C++" {
+
+namespace __cxxabiv1
+{
+  class __class_type_info;
+} // namespace __cxxabiv1
+
+#if !__GXX_WEAK__
+  // If weak symbols are not supported, typeinfo names are not merged.
+  #define __GXX_MERGED_TYPEINFO_NAMES 0
+#else
+  // On platforms that support weak symbols, typeinfo names are merged.
+  #define __GXX_MERGED_TYPEINFO_NAMES 1
+#endif
+
+namespace std 
+{
+  /**
+   *  @brief  Part of RTTI.
+   *
+   *  The @c type_info class describes type information generated by
+   *  an implementation.
+  */
+  class type_info 
+  {
+  public:
+    /** Destructor. Being the first non-inline virtual function, this
+     *  controls in which translation unit the vtable is emitted. The
+     *  compiler makes use of that information to know where to emit
+     *  the runtime-mandated type_info structures in the new-abi.  */
+    virtual ~type_info();
+
+  private:
+    /// Assigning type_info is not supported.  Made private.
+    type_info& operator=(const type_info&);
+    type_info(const type_info&);
+    
+  protected:
+    const char *__name;
+    
+  protected:
+    explicit type_info(const char *__n): __name(__n) { }
+    
+  public:
+    // the public interface
+    /** Returns an @e implementation-defined byte string; this is not
+     *  portable between compilers!  */
+    const char* name() const
+    { return __name; }
+
+#if !__GXX_MERGED_TYPEINFO_NAMES
+    bool before(const type_info& __arg) const;
+    // In old abi, or when weak symbols are not supported, there can
+    // be multiple instances of a type_info object for one
+    // type. Uniqueness must use the _name value, not object address.
+    bool operator==(const type_info& __arg) const;
+#else
+    /** Returns true if @c *this precedes @c __arg in the implementation's
+     *  collation order.  */
+    // In new abi we can rely on type_info's NTBS being unique,
+    // and therefore address comparisons are sufficient.
+    bool before(const type_info& __arg) const
+    { return __name < __arg.__name; }
+    bool operator==(const type_info& __arg) const
+    { return __name == __arg.__name; }
+#endif
+    bool operator!=(const type_info& __arg) const
+    { return !operator==(__arg); }
+    
+    // the internal interface
+  public:
+    // return true if this is a pointer type of some kind
+    virtual bool __is_pointer_p() const;
+    // return true if this is a function type
+    virtual bool __is_function_p() const;
+
+    // Try and catch a thrown type. Store an adjusted pointer to the
+    // caught type in THR_OBJ. If THR_TYPE is not a pointer type, then
+    // THR_OBJ points to the thrown object. If THR_TYPE is a pointer
+    // type, then THR_OBJ is the pointer itself. OUTER indicates the
+    // number of outer pointers, and whether they were const
+    // qualified.
+    virtual bool __do_catch(const type_info *__thr_type, void **__thr_obj,
+			    unsigned __outer) const;
+
+    // internally used during catch matching
+    virtual bool __do_upcast(const __cxxabiv1::__class_type_info *__target,
+			     void **__obj_ptr) const;
+  };
+
+  /**
+   *  @brief  Thrown during incorrect typecasting.
+   *
+   *  If you attempt an invalid @c dynamic_cast expression, an instance of
+   *  this class (or something derived from this class) is thrown.  */
+  class bad_cast : public exception 
+  {
+  public:
+    bad_cast() throw() { }
+    // This declaration is not useless:
+    // http://gcc.gnu.org/onlinedocs/gcc-3.0.2/gcc_6.html#SEC118
+    virtual ~bad_cast() throw();
+  };
+  
+  /** If you use a NULL pointer in a @c typeid expression, this is thrown.  */
+  class bad_typeid : public exception 
+  {
+  public:
+    bad_typeid () throw() { }
+    // This declaration is not useless:
+    // http://gcc.gnu.org/onlinedocs/gcc-3.0.2/gcc_6.html#SEC118
+    virtual ~bad_typeid() throw();
+  };
+} // namespace std
+
+} // extern "C++"
+#endif

misc/uClibc++/include/cxx/unwind-cxx.h

@@ -0,0 +1,213 @@
+// -*- C++ -*- Exception handling and frame unwind runtime interface routines.
+// Copyright (C) 2001 Free Software Foundation, Inc.
+//
+// This file is part of GCC.
+//
+// GCC is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2, or (at your option)
+// any later version.
+//
+// GCC is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with GCC; see the file COPYING.  If not, write to
+// the Free Software Foundation, 59 Temple Place - Suite 330,
+// Boston, MA 02111-1307, USA.
+
+// As a special exception, you may use this file as part of a free software
+// library without restriction.  Specifically, if other files instantiate
+// templates or use macros or inline functions from this file, or you compile
+// this file and link it with other files to produce an executable, this
+// file does not by itself cause the resulting executable to be covered by
+// the GNU General Public License.  This exception does not however
+// invalidate any other reasons why the executable file might be covered by
+// the GNU General Public License.
+
+// This is derived from the C++ ABI for IA-64.  Where we diverge
+// for cross-architecture compatibility are noted with "@@@".
+
+#ifndef _UNWIND_CXX_H
+#define _UNWIND_CXX_H 1
+
+// Level 2: C++ ABI
+
+#include <typeinfo>
+#include <exception>
+#include <cstddef>
+#include "unwind.h"
+
+#pragma GCC visibility push(default)
+
+namespace __cxxabiv1
+{
+
+// A primary C++ exception object consists of a header, which is a wrapper
+// around an unwind object header with additional C++ specific information,
+// followed by the exception object itself.
+
+struct __cxa_exception
+{ 
+  // Manage the exception object itself.
+  std::type_info *exceptionType;
+  void (*exceptionDestructor)(void *); 
+
+  // The C++ standard has entertaining rules wrt calling set_terminate
+  // and set_unexpected in the middle of the exception cleanup process.
+  std::unexpected_handler unexpectedHandler;
+  std::terminate_handler terminateHandler;
+
+  // The caught exception stack threads through here.
+  __cxa_exception *nextException;
+
+  // How many nested handlers have caught this exception.  A negated
+  // value is a signal that this object has been rethrown.
+  int handlerCount;
+
+  // Cache parsed handler data from the personality routine Phase 1
+  // for Phase 2 and __cxa_call_unexpected.
+  int handlerSwitchValue;
+  const unsigned char *actionRecord;
+  const unsigned char *languageSpecificData;
+  _Unwind_Ptr catchTemp;
+  void *adjustedPtr;
+
+  // The generic exception header.  Must be last.
+  _Unwind_Exception unwindHeader;
+};
+
+
+// A dependent C++ exception object consists of a header, which is a wrapper
+// around an unwind object header with additional C++ specific information,
+// followed by the exception object itself.
+struct __cxa_dependent_exception
+{
+  // The primary exception
+  void *primaryException;
+
+  // The C++ standard has entertaining rules wrt calling set_terminate
+  // and set_unexpected in the middle of the exception cleanup process.
+  std::unexpected_handler unexpectedHandler;
+  std::terminate_handler terminateHandler;
+
+  // The caught exception stack threads through here.
+  __cxa_exception *nextException;
+
+  // How many nested handlers have caught this exception.  A negated
+  // value is a signal that this object has been rethrown.
+  int handlerCount;
+
+  // Cache parsed handler data from the personality routine Phase 1
+  // for Phase 2 and __cxa_call_unexpected.
+  int handlerSwitchValue;
+  const unsigned char *actionRecord;
+  const unsigned char *languageSpecificData;
+  _Unwind_Ptr catchTemp;
+  void *adjustedPtr;
+
+  // The generic exception header.  Must be last.
+  _Unwind_Exception unwindHeader;
+};
+
+
+// Each thread in a C++ program has access to a __cxa_eh_globals object.
+struct __cxa_eh_globals
+{
+  __cxa_exception *caughtExceptions;
+  unsigned int uncaughtExceptions;
+};
+
+
+// The __cxa_eh_globals for the current thread can be obtained by using
+// either of the following functions.  The "fast" version assumes at least
+// one prior call of __cxa_get_globals has been made from the current
+// thread, so no initialization is necessary.
+extern "C" __cxa_eh_globals *__cxa_get_globals () throw();
+extern "C" __cxa_eh_globals *__cxa_get_globals_fast () throw();
+
+// Allocate memory for the primary exception plus the thrown object.
+extern "C" void *__cxa_allocate_exception(std::size_t thrown_size) throw();
+// Allocate memory for dependent exception.
+extern "C" __cxa_dependent_exception *__cxa_allocate_dependent_exception() throw();
+
+// Free the space allocated for the primary exception.
+extern "C" void __cxa_free_exception(void *thrown_exception) throw();
+// Free the space allocated for the dependent exception.
+extern "C" void __cxa_free_dependent_exception(__cxa_dependent_exception *dependent_exception) throw();
+
+// Throw the exception.
+extern "C" void __cxa_throw (void *thrown_exception,
+			     std::type_info *tinfo,
+			     void (*dest) (void *))
+     __attribute__((noreturn));
+
+// Used to implement exception handlers.
+extern "C" void *__cxa_begin_catch (void *) throw();
+extern "C" void __cxa_end_catch ();
+extern "C" void __cxa_rethrow () __attribute__((noreturn));
+
+// These facilitate code generation for recurring situations.
+extern "C" void __cxa_bad_cast ();
+extern "C" void __cxa_bad_typeid ();
+
+// @@@ These are not directly specified by the IA-64 C++ ABI.
+
+// Handles re-checking the exception specification if unexpectedHandler
+// throws, and if bad_exception needs to be thrown.  Called from the
+// compiler.
+extern "C" void __cxa_call_unexpected (void *) __attribute__((noreturn));
+
+// Invokes given handler, dying appropriately if the user handler was
+// so inconsiderate as to return.
+extern void __terminate(std::terminate_handler) __attribute__((noreturn));
+extern void __unexpected(std::unexpected_handler) __attribute__((noreturn));
+
+// The current installed user handlers.
+extern std::terminate_handler __terminate_handler;
+extern std::unexpected_handler __unexpected_handler;
+
+// These are explicitly GNU C++ specific.
+
+// This is the exception class we report -- "GNUCC++\0".
+const _Unwind_Exception_Class __gxx_exception_class
+= ((((((((_Unwind_Exception_Class) 'G' 
+	 << 8 | (_Unwind_Exception_Class) 'N')
+	<< 8 | (_Unwind_Exception_Class) 'U')
+       << 8 | (_Unwind_Exception_Class) 'C')
+      << 8 | (_Unwind_Exception_Class) 'C')
+     << 8 | (_Unwind_Exception_Class) '+')
+    << 8 | (_Unwind_Exception_Class) '+')
+   << 8 | (_Unwind_Exception_Class) '\0');
+
+// GNU C++ personality routine, Version 0.
+extern "C" _Unwind_Reason_Code __gxx_personality_v0
+     (int, _Unwind_Action, _Unwind_Exception_Class,
+      struct _Unwind_Exception *, struct _Unwind_Context *);
+
+// GNU C++ sjlj personality routine, Version 0.
+extern "C" _Unwind_Reason_Code __gxx_personality_sj0
+     (int, _Unwind_Action, _Unwind_Exception_Class,
+      struct _Unwind_Exception *, struct _Unwind_Context *);
+
+// Acquire the C++ exception header from the C++ object.
+static inline __cxa_exception *
+__get_exception_header_from_obj (void *ptr)
+{
+  return reinterpret_cast<__cxa_exception *>(ptr) - 1;
+}
+
+// Acquire the C++ exception header from the generic exception header.
+static inline __cxa_exception *
+__get_exception_header_from_ue (_Unwind_Exception *exc)
+{
+  return reinterpret_cast<__cxa_exception *>(exc + 1) - 1;
+}
+
+} /* namespace __cxxabiv1 */
+
+#pragma GCC visibility pop
+
+#endif // _UNWIND_CXX_H

misc/uClibc++/include/cxx/utility

@@ -0,0 +1,88 @@
+/*	Copyright (C) 2004 Garrett A. Kajmowicz
+	This file is part of the uClibc++ Library.
+
+	This library is free software; you can redistribute it and/or
+	modify it under the terms of the GNU Lesser General Public
+	License as published by the Free Software Foundation; either
+	version 2.1 of the License, or (at your option) any later version.
+
+	This library is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+	Lesser General Public License for more details.
+
+	You should have received a copy of the GNU Lesser General Public
+	License along with this library; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+*/
+
+
+#include <basic_definitions>
+
+
+#ifndef __STD_HEADER_UTILITY
+#define __STD_HEADER_UTILITY 1
+
+#pragma GCC visibility push(default)
+
+namespace std{
+
+	namespace rel_ops {
+		template<class T> inline bool operator!=(const T& x, const T& y){
+			return !(x == y);
+		}
+
+		template<class T> inline bool operator> (const T& x, const T& y){
+			return ( y < x);
+		}
+
+		template<class T> inline bool operator<=(const T& x, const T& y){
+			return !( y < x );
+		}
+
+		template<class T> inline bool operator>=(const T& x, const T& y){
+			return !(x < y);
+		}
+	}
+
+	template <class T1, class T2> struct _UCXXEXPORT pair {
+		typedef T1 first_type;
+		typedef T2 second_type;
+
+		T1 first;
+		T2 second;
+		pair() : first(), second() {  }
+		pair(const T1& x, const T2& y) : first(x), second(y) {  }
+		template<class U, class V> pair(const pair<U, V> &p) : first(p.first), second(p.second) { }
+	};
+	
+	template <class T1, class T2> bool operator==(const pair<T1,T2>& x, const pair<T1,T2>& y){
+		using namespace rel_ops;
+		return (x.first == y.first && x.second==y.second);
+	}
+	template <class T1, class T2> bool operator< (const pair<T1,T2>& x, const pair<T1,T2>& y){
+		return x.first < y.first || (!(y.first < x.first) && x.second < y.second);
+	}
+	template <class T1, class T2> bool operator!=(const pair<T1,T2>& x, const pair<T1,T2>& y){
+		return !(x == y);
+	}
+	template <class T1, class T2> bool operator> (const pair<T1,T2>& x, const pair<T1,T2>& y){
+		return y < x;
+	}
+	template <class T1, class T2> bool operator>=(const pair<T1,T2>& x, const pair<T1,T2>& y){
+		return !(x < y);
+	}
+	template <class T1, class T2> bool operator<=(const pair<T1,T2>& x, const pair<T1,T2>& y){
+		return !(y < x);
+	}
+	template <class T1, class T2> pair<T1,T2> make_pair(const T1& x, const T2& y){
+		return pair<T1,T2>(x, y);
+	}
+
+
+}
+
+#pragma GCC visibility pop
+
+#endif	//__STD_HEADER_UTILITY

misc/uClibc++/include/cxx/vector

@@ -0,0 +1,517 @@
+/*	Copyright (C) 2004 Garrett A. Kajmowicz
+
+	This file is part of the uClibc++ Library.
+
+	This library is free software; you can redistribute it and/or
+	modify it under the terms of the GNU Lesser General Public
+	License as published by the Free Software Foundation; either
+	version 2.1 of the License, or (at your option) any later version.
+
+	This library is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+	Lesser General Public License for more details.
+
+	You should have received a copy of the GNU Lesser General Public
+	License along with this library; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+*/
+
+#include <basic_definitions>
+#include <memory>
+#include <iterator>
+#include <func_exception>
+#include <algorithm>
+#include <type_traits>
+
+
+#ifndef __STD_HEADER_VECTOR
+#define __STD_HEADER_VECTOR
+
+#pragma GCC visibility push(default)
+
+namespace std{
+
+	template <class T, class Allocator = allocator<T> > class vector;
+	template <class T, class Allocator> bool operator==(const vector<T,Allocator>& x, const vector<T,Allocator>& y);
+	template <class T, class Allocator> bool operator< (const vector<T,Allocator>& x, const vector<T,Allocator>& y);
+	template <class T, class Allocator> bool operator!=(const vector<T,Allocator>& x, const vector<T,Allocator>& y);
+	template <class T, class Allocator> bool operator> (const vector<T,Allocator>& x, const vector<T,Allocator>& y);
+	template <class T, class Allocator> bool operator>=(const vector<T,Allocator>& x, const vector<T,Allocator>& y);
+	template <class T, class Allocator> bool operator<=(const vector<T,Allocator>& x, const vector<T,Allocator>& y);
+	template <class T, class Allocator> void swap(vector<T,Allocator>& x, vector<T,Allocator>& y);
+
+	template <class T, class Allocator> class _UCXXEXPORT vector {
+	public:
+
+		typedef typename Allocator::reference reference;
+		typedef typename Allocator::const_reference const_reference;
+		typedef typename Allocator::size_type size_type;
+		typedef typename Allocator::difference_type difference_type;
+		typedef typename Allocator::pointer pointer;
+		typedef typename Allocator::const_pointer const_pointer;
+
+		typedef T* iterator;
+		typedef const T* const_iterator;
+		typedef T value_type;
+		typedef Allocator allocator_type;
+		typedef std::reverse_iterator<iterator> reverse_iterator;
+		typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+
+		explicit _UCXXEXPORT vector(const Allocator& al= Allocator()): data(0), //defaultValue(T()),
+			data_size(__UCLIBCXX_STL_BUFFER_SIZE__), elements(0), a(al)
+		{
+			data = a.allocate(data_size);
+		}
+
+		explicit _UCXXEXPORT vector(size_type n, const T& value = T(), const Allocator& al= Allocator()) :
+			data(0), data_size(0), elements(0), a(al)
+		{
+			data_size = n + __UCLIBCXX_STL_BUFFER_SIZE__;
+			data = a.allocate(data_size);
+
+			resize(n, value);
+		}
+
+		template <class InputIterator> _UCXXEXPORT
+			vector(InputIterator first, InputIterator last, const Allocator& al = Allocator()):
+			data(0), data_size(__UCLIBCXX_STL_BUFFER_SIZE__), elements(0), a(al)
+		{
+			data = a.allocate(data_size);
+			assign(first, last);
+		}
+
+		_UCXXEXPORT vector(const vector<T,Allocator>& x){
+			a = x.a;
+
+			elements  = x.elements;
+			data_size = elements + __UCLIBCXX_STL_BUFFER_SIZE__;
+			data = a.allocate(data_size);
+
+			for(size_type i = 0; i < elements; i++){
+				a.construct(data+i, x.data[i]);
+			}
+		}
+
+		_UCXXEXPORT ~vector();	//Below
+
+		_UCXXEXPORT vector<T,Allocator>& operator=(const vector<T,Allocator>& x){
+			if(&x == this){
+				return *this;
+			}
+
+			reserve(x.elements);	//Make sure that we have enough actual memory
+
+
+			//Copy as many elements as possible
+
+			size_t minElements = elements;
+			if(minElements > x.elements){
+				minElements = x.elements;
+			}
+			for(size_t i = 0; i < minElements; ++i){
+				data[i] = x.data[i];
+			}
+
+			//If we need to add new elements
+			if(elements < x.elements){
+				for(size_t i = elements; i< x.elements; ++i){
+					a.construct(data+i, x.data[i]);
+					++elements;
+				}
+			}
+
+			if(elements > x.elements){
+				downsize(x.elements);
+			}
+
+			return *this;
+		}
+
+		template <class InputIterator> _UCXXEXPORT void assign(InputIterator first, InputIterator last){
+			clear();
+			insert(begin(), first, last);
+		}
+
+		template <class Size, class U> _UCXXEXPORT void assign(Size n, const U& u = U()){
+			clear();
+			resize(n, u);
+		}
+
+		inline allocator_type get_allocator() const{
+			return a;
+		}
+
+		inline iterator begin(){
+			return data;
+		}
+
+		inline const_iterator begin() const{
+			return data;
+		}
+
+		inline iterator end(){
+			return (data + elements);
+		}
+
+		inline const_iterator end() const{
+			return (data + elements);
+		}
+
+		inline reverse_iterator rbegin(){
+			return reverse_iterator(end());
+		}
+
+		inline const_reverse_iterator rbegin() const{
+			return const_reverse_iterator(end());
+		}
+
+		inline reverse_iterator rend(){
+			return reverse_iterator(begin());
+		}
+
+		inline const_reverse_iterator rend() const{
+			return const_reverse_iterator(begin());
+		}
+
+		inline size_type size() const{
+			return elements;
+		}
+
+		_UCXXEXPORT size_type max_size() const{
+			return ((size_type)(-1)) / sizeof(T);
+		}
+
+		void downsize(size_type sz);
+		void resize(size_type sz, const T & c = T());
+
+		inline size_type capacity() const{
+			return data_size;
+		}
+
+		inline bool empty() const{
+			return (size() == 0);
+		}
+
+		void reserve(size_type n);
+
+		inline reference operator[](size_type n){
+			return data[n];
+		}
+
+		inline const_reference operator[](size_type n) const{
+			return data[n];
+		}
+
+		_UCXXEXPORT const_reference at(size_type n) const{
+			if(n >= elements){
+				__throw_out_of_range("Invalid subscript");
+			}
+			return data[n];
+		}
+
+		_UCXXEXPORT reference at(size_type n){
+			if(n >= elements){
+				__throw_out_of_range("Invalid subscript");
+			}
+			return data[n];
+		}
+
+		inline reference front(){
+			return data[0];
+		}
+
+		inline const_reference front() const{
+			return data[0];
+		}
+
+		inline reference back(){
+			return data[ size() - 1];
+		}
+
+		inline const_reference back() const{
+			return data[ size() - 1 ];
+		}
+
+		inline void push_back(const T& x){
+			resize( size() + 1, x);
+		}
+
+		inline void pop_back(){
+			downsize(size() - 1);
+		}
+
+		_UCXXEXPORT iterator insert(iterator position, const T& x = T()){
+			size_type index = position - data;
+			resize(size() + 1, x);
+			for(size_type i = elements - 1; i > index; --i){
+				data[i] = data[i-1];
+			}
+			data[index] = x;
+			return (data + index);
+		}
+
+		_UCXXEXPORT void _insert_fill(iterator position, size_type n, const T & x){
+			size_type index = position - data;
+			resize(size() + n, x);
+
+			for(size_type i = elements -1; (i > (index+n-1)); --i){
+				data[i] = data[i-n];
+			}
+			for(size_type i = 0; i < n; i++){
+				data[i + index]  = x;
+			}
+		}
+
+		template <class InputIterator> _UCXXEXPORT
+			void _insert_from_iterator(iterator position, InputIterator first, InputIterator last)
+		{
+			T temp;
+			while(first !=last){
+				temp = *first;
+				position = insert(position, temp);
+				++position;
+				++first;
+			}
+		}
+
+		template <class InputIterator>
+			inline void _dispatch_insert(iterator position, InputIterator first, InputIterator last, __true_type)
+		{
+			_insert_fill(position, first, last);
+		}
+
+		template <class InputIterator>
+			inline void _dispatch_insert(iterator position, InputIterator first, InputIterator last, __false_type)
+		{
+				_insert_from_iterator(position, first, last);
+		}
+
+		inline void insert(iterator position, size_type n, const T& x ){
+			_insert_fill(position, n, x);
+		}
+
+		template <class InputIterator> inline void insert(iterator position, InputIterator first, InputIterator last){
+			typedef typename __is_integer<InputIterator>::value __some_type;
+			_dispatch_insert(position, first, last, __some_type());
+		}
+
+		_UCXXEXPORT iterator erase(iterator position){
+			size_type index = position - data;
+			for(size_type i = index; i < (elements - 1); ++i){
+				data[i] = data[i+1];
+			}
+			downsize(size() - 1);
+			return (data + index);
+		}
+
+		_UCXXEXPORT iterator erase(iterator first, iterator last){
+			size_type index = first - data;
+			size_type width = last - first;
+			for(size_type i = index; i < (elements - width) ;++i){
+				data[i] = data[i+width];
+			}
+			downsize(size() - width);
+			return (data + index);
+		}
+
+		_UCXXEXPORT void swap(vector<T,Allocator>& v){
+			if(this == &v){		//Avoid dv.swap(v)
+				return;
+			}
+			T* ptr;
+			size_type temp;
+
+			//Swap pointers first
+			ptr = data;
+			data = v.data;
+			v.data  = ptr;
+
+			//Swap element counts
+			temp = elements;
+			elements = v.elements;
+			v.elements = temp;
+
+			//Swap data size
+			temp = data_size;
+			data_size = v.data_size;
+			v.data_size = temp;
+		}
+
+		_UCXXEXPORT void clear(){
+			downsize(0);
+		}
+
+	protected:
+		T* data;
+		size_type data_size;
+		size_type elements;
+		Allocator a;
+	};
+
+
+
+	//Here go template instantiations
+
+	template<class T, class Allocator> _UCXXEXPORT vector<T, Allocator>::~vector(){
+		for(size_t i = 0; i < elements; ++i){
+			a.destroy(data + i);
+		}
+		a.deallocate(data, data_size);
+	}
+
+
+	template<class T, class Allocator> _UCXXEXPORT void vector<T, Allocator>::reserve(size_type n){
+		if(n > data_size){	//We never shrink...
+			T * temp_ptr = data;
+			size_type temp_size = data_size;
+
+			data_size = n;
+			data = a.allocate(data_size);
+
+			for(size_type i = 0; i<elements; ++i){
+				a.construct(data+i, temp_ptr[i]);
+				a.destroy(temp_ptr+i);
+			}
+			a.deallocate(temp_ptr, temp_size);
+		}
+	}
+
+	template<class T, class Allocator> _UCXXEXPORT void vector<T, Allocator>::resize(size_type sz, const T & c){
+		if(sz > elements){      //Need to actually call constructor
+			if(sz > data_size){
+				reserve(sz + __UCLIBCXX_STL_BUFFER_SIZE__);
+			}
+
+			for(size_type i = elements; i<sz ; ++i){
+				a.construct(data+i, c);
+			}
+			elements = sz;
+		}else{
+			downsize(sz);
+		}
+	}
+
+	template<class T, class Allocator> _UCXXEXPORT void vector<T, Allocator>::downsize(size_type sz){
+		if(sz < elements){      //Actually are downsizing
+			for(size_t i = sz; i< elements; ++i){
+				a.destroy(data+i);
+			}
+			elements = sz;
+		}
+	}
+
+
+#ifndef __UCLIBCXX_COMPILE_VECTOR__
+#ifdef __UCLIBCXX_EXPAND_VECTOR_BASIC__
+
+
+#ifdef __UCLIBCXX_EXPAND_CONSTRUCTORS_DESTRUCTORS__
+	template<> _UCXXEXPORT vector<char, allocator<char> >::vector(const allocator<char>& al);
+	template<> _UCXXEXPORT vector<char, allocator<char> >::vector(size_type n, const char & value, const allocator<char> & al);
+
+	template<> _UCXXEXPORT vector<char, allocator<char> >::~vector();
+	template<> _UCXXEXPORT vector<unsigned char, allocator<unsigned char> >::~vector();
+
+#endif //__UCLIBCXX_EXPAND_CONSTRUCTORS_DESTRUCTORS__
+
+	template<> _UCXXEXPORT void vector<char, allocator<char> >::reserve(size_type n);
+	template<> _UCXXEXPORT void vector<unsigned char, allocator<unsigned char> >::reserve(size_type n);
+	template<> _UCXXEXPORT void vector<short int, allocator<short int> >::reserve(size_type n);
+	template<> _UCXXEXPORT void vector<unsigned short int, allocator<unsigned short int> >::reserve(size_type n);
+	template<> _UCXXEXPORT void vector<int, allocator<int> >::reserve(size_type n);
+	template<> _UCXXEXPORT void vector<unsigned int, allocator<unsigned int> >::reserve(size_type n);
+	template<> _UCXXEXPORT void vector<long int, allocator<long int> >::reserve(size_type n);
+	template<> _UCXXEXPORT void vector<unsigned long int, allocator<unsigned long int> >::reserve(size_type n);
+	template<> _UCXXEXPORT void vector<float, allocator<float> >::reserve(size_type n);
+	template<> _UCXXEXPORT void vector<double, allocator<double> >::reserve(size_type n);
+	template<> _UCXXEXPORT void vector<bool, allocator<bool> >::reserve(size_type n);
+
+	template<> _UCXXEXPORT void vector<char, allocator<char> >::resize(size_type sz, const char & c);
+	template<> _UCXXEXPORT void
+		vector<unsigned char, allocator<unsigned char> >::resize(size_type sz, const unsigned char & c);
+	template<> _UCXXEXPORT void vector<short int, allocator<short int> >::resize(size_type sz, const short & c);
+	template<> _UCXXEXPORT void
+		vector<unsigned short int, allocator<unsigned short int> >::resize(size_type sz, const unsigned short int & c);
+	template<> _UCXXEXPORT void vector<int, allocator<int> >::resize(size_type sz, const int & c);
+	template<> _UCXXEXPORT void vector<unsigned int, allocator<unsigned int> >::resize(size_type sz, const unsigned int & c);
+	template<> _UCXXEXPORT void vector<long int, allocator<long int> >::resize(size_type sz, const long int & c);
+	template<> _UCXXEXPORT void
+		vector<unsigned long int, allocator<unsigned long int> >::resize(size_type sz, const unsigned long int & c);
+	template<> _UCXXEXPORT void vector<float, allocator<float> >::resize(size_type sz, const float & c);
+	template<> _UCXXEXPORT void vector<double, allocator<double> >::resize(size_type sz, const double & c);
+	template<> _UCXXEXPORT void vector<bool, allocator<bool> >::resize(size_type sz, const bool & c);
+
+#elif defined __UCLIBCXX_EXPAND_STRING_CHAR__
+
+#ifdef __UCLIBCXX_EXPAND_CONSTRUCTORS_DESTRUCTORS__
+
+	template<> _UCXXEXPORT vector<char, allocator<char> >::vector(const allocator<char>& al);
+	template<> _UCXXEXPORT vector<char, allocator<char> >::vector(size_type n, const char & value, const allocator<char> & al);
+	template<> _UCXXEXPORT vector<char, allocator<char> >::~vector();
+
+#endif
+
+	template<> _UCXXEXPORT void vector<char, allocator<char> >::reserve(size_type n);
+	template<> _UCXXEXPORT void vector<char, allocator<char> >::resize(size_type sz, const char & c);
+
+#endif
+#endif
+
+
+
+	template <class T, class Allocator> _UCXXEXPORT bool
+		operator==(const vector<T,Allocator>& x, const vector<T,Allocator>& y)
+	{
+		if(x.size() !=y.size() ){
+			return false;
+		}
+		for(size_t i = 0; i < x.size(); ++i){
+			if(x[i] != y[i]){
+				return false;
+			}
+		}
+		return true;
+	}
+
+	template <class T, class Allocator> _UCXXEXPORT bool
+		operator< (const vector<T,Allocator>& x, const vector<T,Allocator>& y)
+	{
+		less<typename iterator_traits<typename vector<T,Allocator>::iterator >::value_type> c;
+		return lexicographical_compare(x.begin(), x.end(), y.begin(), y.end(), c);
+	}
+	template <class T, class Allocator> _UCXXEXPORT bool
+		operator!=(const vector<T,Allocator>& x, const vector<T,Allocator>& y)
+	{
+		return !(x == y);
+	}
+	template <class T, class Allocator> _UCXXEXPORT bool
+		operator> (const vector<T,Allocator>& x, const vector<T,Allocator>& y)
+	{
+		greater<typename iterator_traits<typename vector<T,Allocator>::iterator >::value_type> c;
+		return lexicographical_compare(x.begin(), x.end(), y.begin(), y.end(), c);
+	}
+	template <class T, class Allocator> _UCXXEXPORT bool
+		operator>=(const vector<T,Allocator>& x, const vector<T,Allocator>& y)
+	{
+		greater_equal<typename iterator_traits<typename vector<T,Allocator>::iterator >::value_type> c;
+		return lexicographical_compare(x.begin(), x.end(), y.begin(), y.end(), c);
+	}
+	template <class T, class Allocator> _UCXXEXPORT bool
+		operator<=(const vector<T,Allocator>& x, const vector<T,Allocator>& y)
+	{
+		less_equal<typename iterator_traits<typename vector<T,Allocator>::iterator >::value_type> c;
+		return lexicographical_compare(x.begin(), x.end(), y.begin(), y.end(), c);
+	}
+
+	template <class T, class Allocator> _UCXXEXPORT void swap(vector<T,Allocator>& x, vector<T,Allocator>& y){
+		x.swap(y);
+	}
+
+}
+
+#pragma GCC visibility pop
+
+#endif
+

misc/uClibc++/include/features.h

@@ -0,0 +1,451 @@
+/* Copyright (C) 1991-1993,1995-2006,2007,2009 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, write to the Free
+   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+   02111-1307 USA.  */
+
+#ifndef	_FEATURES_H
+#define	_FEATURES_H	1
+
+/* These are defined by the user (or the compiler)
+   to specify the desired environment:
+
+   __STRICT_ANSI__	ISO Standard C.
+   _ISOC99_SOURCE	Extensions to ISO C89 from ISO C99.
+   _POSIX_SOURCE	IEEE Std 1003.1.
+   _POSIX_C_SOURCE	If ==1, like _POSIX_SOURCE; if >=2 add IEEE Std 1003.2;
+			if >=199309L, add IEEE Std 1003.1b-1993;
+			if >=199506L, add IEEE Std 1003.1c-1995;
+			if >=200112L, all of IEEE 1003.1-2004
+			if >=200809L, all of IEEE 1003.1-2008
+   _XOPEN_SOURCE	Includes POSIX and XPG things.  Set to 500 if
+			Single Unix conformance is wanted, to 600 for the
+			sixth revision, to 700 for the seventh revision.
+   _XOPEN_SOURCE_EXTENDED XPG things and X/Open Unix extensions.
+   _LARGEFILE_SOURCE	Some more functions for correct standard I/O.
+   _LARGEFILE64_SOURCE	Additional functionality from LFS for large files.
+   _FILE_OFFSET_BITS=N	Select default filesystem interface.
+   _BSD_SOURCE		ISO C, POSIX, and 4.3BSD things.
+   _SVID_SOURCE		ISO C, POSIX, and SVID things.
+   _ATFILE_SOURCE	Additional *at interfaces.
+   _GNU_SOURCE		All of the above, plus GNU extensions.
+   _REENTRANT		Select additionally reentrant object.
+   _THREAD_SAFE		Same as _REENTRANT, often used by other systems.
+   _FORTIFY_SOURCE	If set to numeric value > 0 additional security
+			measures are defined, according to level.
+
+   The `-ansi' switch to the GNU C compiler defines __STRICT_ANSI__.
+   If none of these are defined, the default is to have _SVID_SOURCE,
+   _BSD_SOURCE, and _POSIX_SOURCE set to one and _POSIX_C_SOURCE set to
+   200112L.  If more than one of these are defined, they accumulate.
+   For example __STRICT_ANSI__, _POSIX_SOURCE and _POSIX_C_SOURCE
+   together give you ISO C, 1003.1, and 1003.2, but nothing else.
+
+   These are defined by this file and are used by the
+   header files to decide what to declare or define:
+
+   __USE_ISOC99		Define ISO C99 things.
+   __USE_ISOC95		Define ISO C90 AMD1 (C95) things.
+   __USE_POSIX		Define IEEE Std 1003.1 things.
+   __USE_POSIX2		Define IEEE Std 1003.2 things.
+   __USE_POSIX199309	Define IEEE Std 1003.1, and .1b things.
+   __USE_POSIX199506	Define IEEE Std 1003.1, .1b, .1c and .1i things.
+   __USE_XOPEN		Define XPG things.
+   __USE_XOPEN_EXTENDED	Define X/Open Unix things.
+   __USE_UNIX98		Define Single Unix V2 things.
+   __USE_XOPEN2K        Define XPG6 things.
+   __USE_XOPEN2K8       Define XPG7 things.
+   __USE_LARGEFILE	Define correct standard I/O things.
+   __USE_LARGEFILE64	Define LFS things with separate names.
+   __USE_FILE_OFFSET64	Define 64bit interface as default.
+   __USE_BSD		Define 4.3BSD things.
+   __USE_SVID		Define SVID things.
+   __USE_MISC		Define things common to BSD and System V Unix.
+   __USE_ATFILE		Define *at interfaces and AT_* constants for them.
+   __USE_GNU		Define GNU extensions.
+   __USE_REENTRANT	Define reentrant/thread-safe *_r functions.
+   __USE_FORTIFY_LEVEL	Additional security measures used, according to level.
+   __FAVOR_BSD		Favor 4.3BSD things in cases of conflict.
+
+   The macros `__GNU_LIBRARY__', `__GLIBC__', and `__GLIBC_MINOR__' are
+   defined by this file unconditionally.  `__GNU_LIBRARY__' is provided
+   only for compatibility.  All new code should use the other symbols
+   to test for features.
+
+   All macros listed above as possibly being defined by this file are
+   explicitly undefined if they are not explicitly defined.
+   Feature-test macros that are not defined by the user or compiler
+   but are implied by the other feature-test macros defined (or by the
+   lack of any definitions) are defined by the file.  */
+
+
+/* Undefine everything, so we get a clean slate.  */
+#undef	__USE_ISOC99
+#undef	__USE_ISOC95
+#undef	__USE_POSIX
+#undef	__USE_POSIX2
+#undef	__USE_POSIX199309
+#undef	__USE_POSIX199506
+#undef	__USE_XOPEN
+#undef	__USE_XOPEN_EXTENDED
+#undef	__USE_UNIX98
+#undef	__USE_XOPEN2K
+#undef	__USE_XOPEN2K8
+#undef	__USE_LARGEFILE
+#undef	__USE_LARGEFILE64
+#undef	__USE_FILE_OFFSET64
+#undef	__USE_BSD
+#undef	__USE_SVID
+#undef	__USE_MISC
+#undef	__USE_ATFILE
+#undef	__USE_GNU
+#undef	__USE_REENTRANT
+#undef	__USE_FORTIFY_LEVEL
+#undef	__FAVOR_BSD
+#undef	__KERNEL_STRICT_NAMES
+
+/* Suppress kernel-name space pollution unless user expressedly asks
+   for it.  */
+#ifndef _LOOSE_KERNEL_NAMES
+# define __KERNEL_STRICT_NAMES
+#endif
+
+/* Always use ISO C things.  */
+#define	__USE_ANSI	1
+
+/* Convenience macros to test the versions of glibc and gcc.
+   Use them like this:
+   #if __GNUC_PREREQ (2,8)
+   ... code requiring gcc 2.8 or later ...
+   #endif
+   Note - they won't work for gcc1 or glibc1, since the _MINOR macros
+   were not defined then.  */
+#if defined __GNUC__ && defined __GNUC_MINOR__
+# define __GNUC_PREREQ(maj, min) \
+	((__GNUC__ << 16) + __GNUC_MINOR__ >= ((maj) << 16) + (min))
+#else
+# define __GNUC_PREREQ(maj, min) 0
+#endif
+
+
+/* If _BSD_SOURCE was defined by the user, favor BSD over POSIX.  */
+#if defined _BSD_SOURCE && \
+    !(defined _POSIX_SOURCE || defined _POSIX_C_SOURCE || \
+      defined _XOPEN_SOURCE || defined _XOPEN_SOURCE_EXTENDED || \
+      defined _GNU_SOURCE || defined _SVID_SOURCE)
+# define __FAVOR_BSD	1
+#endif
+
+/* If _GNU_SOURCE was defined by the user, turn on all the other features.  */
+#ifdef _GNU_SOURCE
+# undef  _ISOC99_SOURCE
+# define _ISOC99_SOURCE	1
+# undef  _POSIX_SOURCE
+# define _POSIX_SOURCE	1
+# undef  _POSIX_C_SOURCE
+# define _POSIX_C_SOURCE	200809L
+# undef  _XOPEN_SOURCE
+# define _XOPEN_SOURCE	700
+# undef  _XOPEN_SOURCE_EXTENDED
+# define _XOPEN_SOURCE_EXTENDED	1
+# undef	 _LARGEFILE64_SOURCE
+# define _LARGEFILE64_SOURCE	1
+# undef  _BSD_SOURCE
+# define _BSD_SOURCE	1
+# undef  _SVID_SOURCE
+# define _SVID_SOURCE	1
+# undef  _ATFILE_SOURCE
+# define _ATFILE_SOURCE	1
+#endif
+
+/* This macro indicates that the installed library is uClibc.  Use
+ * __UCLIBC_MAJOR__ and __UCLIBC_MINOR__ to test for the features in
+ * specific releases.  */
+#define	__UCLIBC__		1
+
+#ifdef __UCLIBC__
+/* Load up the current set of uClibc supported features along
+ * with the current uClibc major and minor version numbers.
+ * For uClibc release 0.9.26, these numbers would be:
+ *	#define	__UCLIBC_MAJOR__	0
+ *	#define	__UCLIBC_MINOR__	9
+ *	#define	__UCLIBC_SUBLEVEL__	26
+ */
+# define __need_uClibc_config_h
+# include <bits/uClibc_config.h>
+# undef __need_uClibc_config_h
+
+/* For uClibc, always optimize for size -- this should disable
+ * a lot of expensive inlining...
+ * TODO: this is wrong! __OPTIMIZE_SIZE__ is an indicator of
+ * gcc -Os compile. We should not mess with compiler inlines.
+ * We should instead disable __USE_EXTERN_INLINES unconditionally,
+ * or maybe actually audit and test uclibc to work correctly
+ * with __USE_EXTERN_INLINES on.
+ */
+# define __OPTIMIZE_SIZE__   1
+
+/* disable unsupported features */
+# undef __LDBL_COMPAT
+
+# ifndef __UCLIBC_HAS_FORTIFY__
+#  undef _FORTIFY_SOURCE
+# endif
+
+# ifndef __UCLIBC_HAS_THREADS__
+#  if defined _REENTRANT || defined _THREAD_SAFE
+#   warning requested reentrant code, but thread support was disabled
+#   undef _REENTRANT
+#   undef _THREAD_SAFE
+#  endif
+# endif
+
+# ifndef __UCLIBC_HAS_LFS__
+#  undef _LARGEFILE64_SOURCE
+/* NOTE: This is probably incorrect on a 64-bit arch... */
+#  if defined _FILE_OFFSET_BITS && _FILE_OFFSET_BITS == 64
+#   error It appears you have defined _FILE_OFFSET_BITS=64.  Unfortunately, \
+uClibc was built without large file support enabled.
+#  endif
+# elif defined __BCC__
+#  error BCC does not support LFS, please disable it
+# endif
+#endif /* __UCLIBC__ */
+
+/* If nothing (other than _GNU_SOURCE) is defined,
+   define _BSD_SOURCE and _SVID_SOURCE.  */
+#if (!defined __STRICT_ANSI__ && !defined _ISOC99_SOURCE && \
+     !defined _POSIX_SOURCE && !defined _POSIX_C_SOURCE && \
+     !defined _XOPEN_SOURCE && !defined _XOPEN_SOURCE_EXTENDED && \
+     !defined _BSD_SOURCE && !defined _SVID_SOURCE)
+# define _BSD_SOURCE	1
+# define _SVID_SOURCE	1
+#endif
+
+/* This is to enable the ISO C99 extension.  Also recognize the old macro
+   which was used prior to the standard acceptance.  This macro will
+   eventually go away and the features enabled by default once the ISO C99
+   standard is widely adopted.  */
+#if (defined _ISOC99_SOURCE || defined _ISOC9X_SOURCE \
+     || (defined __STDC_VERSION__ && __STDC_VERSION__ >= 199901L))
+# define __USE_ISOC99	1
+#endif
+
+/* This is to enable the ISO C90 Amendment 1:1995 extension.  */
+#if (defined _ISOC99_SOURCE || defined _ISOC9X_SOURCE \
+     || (defined __STDC_VERSION__ && __STDC_VERSION__ >= 199409L))
+# define __USE_ISOC95	1
+#endif
+
+/* If none of the ANSI/POSIX macros are defined, use POSIX.1 and POSIX.2
+   (and IEEE Std 1003.1b-1993 unless _XOPEN_SOURCE is defined).  */
+#if ((!defined __STRICT_ANSI__ || (_XOPEN_SOURCE - 0) >= 500) && \
+     !defined _POSIX_SOURCE && !defined _POSIX_C_SOURCE)
+# define _POSIX_SOURCE	1
+# if defined _XOPEN_SOURCE && (_XOPEN_SOURCE - 0) < 500
+#  define _POSIX_C_SOURCE	2
+# elif defined _XOPEN_SOURCE && (_XOPEN_SOURCE - 0) < 600
+#  define _POSIX_C_SOURCE	199506L
+# elif defined _XOPEN_SOURCE && (_XOPEN_SOURCE - 0) < 700
+#  define _POSIX_C_SOURCE	200112L
+# else
+#  define _POSIX_C_SOURCE	200809L
+# endif
+# define __USE_POSIX_IMPLICITLY	1
+#endif
+
+#if defined _POSIX_SOURCE || _POSIX_C_SOURCE >= 1 || defined _XOPEN_SOURCE
+# define __USE_POSIX	1
+#endif
+
+#if defined _POSIX_C_SOURCE && _POSIX_C_SOURCE >= 2 || defined _XOPEN_SOURCE
+# define __USE_POSIX2	1
+#endif
+
+#if (_POSIX_C_SOURCE - 0) >= 199309L
+# define __USE_POSIX199309	1
+#endif
+
+#if (_POSIX_C_SOURCE - 0) >= 199506L
+# define __USE_POSIX199506	1
+#endif
+
+#if (_POSIX_C_SOURCE - 0) >= 200112L
+# define __USE_XOPEN2K		1
+# undef __USE_ISOC99
+# define __USE_ISOC99		1
+#endif
+
+#if (_POSIX_C_SOURCE - 0) >= 200809L
+# define __USE_XOPEN2K8		1
+# undef  _ATFILE_SOURCE
+# define _ATFILE_SOURCE	1
+#endif
+
+#ifdef	_XOPEN_SOURCE
+# define __USE_XOPEN	1
+# if (_XOPEN_SOURCE - 0) >= 500
+#  define __USE_XOPEN_EXTENDED	1
+#  define __USE_UNIX98	1
+#  undef _LARGEFILE_SOURCE
+#  define _LARGEFILE_SOURCE	1
+#  if (_XOPEN_SOURCE - 0) >= 600
+#   if (_XOPEN_SOURCE - 0) >= 700
+#    define __USE_XOPEN2K8	1
+#   endif
+#   define __USE_XOPEN2K	1
+#   undef __USE_ISOC99
+#   define __USE_ISOC99		1
+#  endif
+# else
+#  ifdef _XOPEN_SOURCE_EXTENDED
+#   define __USE_XOPEN_EXTENDED	1
+#  endif
+# endif
+#endif
+
+#ifdef _LARGEFILE_SOURCE
+# define __USE_LARGEFILE	1
+#endif
+
+#ifdef _LARGEFILE64_SOURCE
+# define __USE_LARGEFILE64	1
+#endif
+
+#if defined _FILE_OFFSET_BITS && _FILE_OFFSET_BITS == 64
+# define __USE_FILE_OFFSET64	1
+#endif
+
+#if defined _BSD_SOURCE || defined _SVID_SOURCE
+# define __USE_MISC	1
+#endif
+
+#ifdef	_BSD_SOURCE
+# define __USE_BSD	1
+#endif
+
+#ifdef	_SVID_SOURCE
+# define __USE_SVID	1
+#endif
+
+#ifdef	_ATFILE_SOURCE
+# define __USE_ATFILE	1
+#endif
+
+#ifdef	_GNU_SOURCE
+# define __USE_GNU	1
+#endif
+
+#if defined _REENTRANT || defined _THREAD_SAFE
+# define __USE_REENTRANT	1
+#endif
+
+#if defined _FORTIFY_SOURCE && _FORTIFY_SOURCE > 0 \
+    && __GNUC_PREREQ (4, 1) && defined __OPTIMIZE__ && __OPTIMIZE__ > 0
+# if _FORTIFY_SOURCE > 1
+#  define __USE_FORTIFY_LEVEL 2
+# else
+#  define __USE_FORTIFY_LEVEL 1
+# endif
+#else
+# define __USE_FORTIFY_LEVEL 0
+#endif
+
+/* We do support the IEC 559 math functionality, real and complex.  */
+#ifdef __UCLIBC_HAS_FLOATS__
+#define __STDC_IEC_559__		1
+#define __STDC_IEC_559_COMPLEX__	1
+#endif
+
+#ifdef __UCLIBC_HAS_WCHAR__
+/* wchar_t uses ISO 10646-1 (2nd ed., published 2000-09-15) / Unicode 3.1.  */
+#define __STDC_ISO_10646__		200009L
+#endif
+
+/*  There is an unwholesomely huge amount of code out there that depends on the
+ *  presence of GNU libc header files.  We have GNU libc header files.  So here
+ *  we commit a horrible sin.  At this point, we _lie_ and claim to be GNU libc
+ *  to make things like /usr/include/linux/socket.h and lots of apps work as
+ *  their developers intended.  This is IMHO, pardonable, since these defines
+ *  are not really intended to check for the presence of a particular library,
+ *  but rather are used to define an _interface_.  */
+#if !defined __FORCE_NOGLIBC && (!defined _LIBC || defined __FORCE_GLIBC)
+/* This macro indicates that the installed library is the GNU C Library.
+   For historic reasons the value now is 6 and this will stay from now
+   on.  The use of this variable is deprecated.  */
+/* uClibc WARNING: leave these aligned to the left, don't put a space after '#', else
+ * broken apps could fail the check. */
+#undef  __GNU_LIBRARY__
+#define __GNU_LIBRARY__ 6
+
+/* Major and minor version number of the GNU C library package.  Use
+   these macros to test for features in specific releases.  */
+/* Don't do it, if you want to keep uClibc happy.  */
+#define	__GLIBC__	2
+#define	__GLIBC_MINOR__	2
+#endif
+
+#define __GLIBC_PREREQ(maj, min) \
+	((__GLIBC__ << 16) + __GLIBC_MINOR__ >= ((maj) << 16) + (min))
+
+#ifndef __UCLIBC__
+/* Decide whether a compiler supports the long long datatypes.  */
+#if defined __GNUC__ \
+    || (defined __PGI && defined __i386__ ) \
+    || (defined __INTEL_COMPILER && (defined __i386__ || defined __ia64__)) \
+    || (defined __STDC_VERSION__ && __STDC_VERSION__ >= 199901L)
+# define __GLIBC_HAVE_LONG_LONG	1
+#endif
+#endif
+
+/* This is here only because every header file already includes this one.  */
+#ifndef __ASSEMBLER__
+# ifndef _SYS_CDEFS_H
+#  include <sys/cdefs.h>
+# endif
+
+/* If we don't have __REDIRECT, prototypes will be missing if
+   __USE_FILE_OFFSET64 but not __USE_LARGEFILE[64]. */
+# if defined __USE_FILE_OFFSET64 && !defined __REDIRECT
+#  define __USE_LARGEFILE	1
+#  ifdef __UCLIBC_HAS_LFS__
+#  define __USE_LARGEFILE64	1
+#  endif
+# endif
+
+#endif	/* !ASSEMBLER */
+
+/* Decide whether we can, and are willing to define extern inline
+ * functions in headers, even if this results in a slightly bigger
+ * code for user programs built against uclibc.
+ * Enabled only in -O2 compiles, not -Os.
+ * uclibc itself is usually built without __USE_EXTERN_INLINES,
+ * remove "&& !defined __OPTIMIZE_SIZE__" part to do otherwise.
+ */
+#if __GNUC_PREREQ (2, 7) && defined __OPTIMIZE__ \
+    && !defined __OPTIMIZE_SIZE__ && !defined __NO_INLINE__ \
+    && (defined __extern_inline || defined __GNUC_GNU_INLINE__ || defined __GNUC_STDC_INLINE__)
+# define __USE_EXTERN_INLINES	1
+#endif
+
+#ifdef _LIBC
+# ifdef __UCLIBC_HAS_LFS__
+#  undef _FILE_OFFSET_BITS
+#  undef __USE_FILE_OFFSET64
+# endif
+# include <libc-internal.h>
+#endif
+
+#endif	/* features.h  */

misc/uClibc++/install.sh

@@ -0,0 +1,312 @@
+#!/bin/bash
+
+usage="USAGE: $0 <full path to the NuttX directory>"
+
+lgpl="\n
+GNU LESSER GENERAL PUBLIC LICENSE\n
+\n
+Version 3, 29 June 2007\n
+\n
+Copyright © 2007 Free Software Foundation, Inc. <http://fsf.org/>\n
+\n
+Everyone is permitted to copy and distribute verbatim copies of this \n
+license document, but changing it is not allowed.\n
+\n
+This version of the GNU Lesser General Public License incorporates the\n
+terms and conditions of version 3 of the GNU General Public License,\n
+supplemented by the additional permissions listed below.\n
+\n
+0. Additional Definitions.\n
+\n
+As used herein, “this License” refers to version 3 of the GNU Lesser\n
+General Public License, and the “GNU GPL” refers to version 3 of the\n
+GNU General Public License.\n
+\n
+“The Library” refers to a covered work governed by this License, other\n
+than an Application or a Combined Work as defined below.\n
+\n
+An “Application” is any work that makes use of an interface provided\n
+by the Library, but which is not otherwise based on the Library. Defining\n
+a subclass of a class defined by the Library is deemed a mode of using an\n
+interface provided by the Library.\n
+\n
+A “Combined Work” is a work produced by combining or linking an\n
+Application with the Library. The particular version of the Library with\n
+which the Combined Work was made is also called the “Linked Version”.\n
+\n
+The “Minimal Corresponding Source” for a Combined Work means the\n
+Corresponding Source for the Combined Work, excluding any source code\n
+for portions of the Combined Work that, considered in isolation, are based\n
+on the Application, and not on the Linked Version.\n
+\n
+The “Corresponding Application Code” for a Combined Work means the object\n
+code and/or source code for the Application, including any data and utility\n
+programs needed for reproducing the Combined Work from the Application,\n
+but excluding the System Libraries of the Combined Work.\n
+\n
+1. Exception to Section 3 of the GNU GPL.\n
+\n
+You may convey a covered work under sections 3 and 4 of this License\n
+without being bound by section 3 of the GNU GPL.\n
+\n
+2. Conveying Modified Versions.\n
+\n
+If you modify a copy of the Library, and, in your modifications, a\n
+facility refers to a function or data to be supplied by an Application\n
+that uses the facility (other than as an argument passed when the facility\n
+is invoked), then you may convey a copy of the modified version:\n
+\n
+    a) under this License, provided that you make a good faith effort to\n
+       ensure that, in the event an Application does not supply the function\n
+       or data, the facility still operates, and performs whatever part of\n
+       its purpose remains meaningful, or\n
+    b) under the GNU GPL, with none of the additional permissions of this\n
+       License applicable to that copy.\n
+\n
+3. Object Code Incorporating Material from Library Header Files.\n
+\n
+The object code form of an Application may incorporate material from a\n
+header file that is part of the Library. You may convey such object code\n
+under terms of your choice, provided that, if the incorporated material is\n
+not limited to numerical parameters, data structure layouts and accessors, or\n
+small macros, inline functions and templates (ten or fewer lines in length),\n
+you do both of the following:\n
+\n
+    a) Give prominent notice with each copy of the object code that the\n
+       Library is used in it and that the Library and its use are covered\n
+       by this License.\n
+    b) Accompany the object code with a copy of the GNU GPL and this license\n
+       document.\n
+\n
+4. Combined Works.\n
+\n
+You may convey a Combined Work under terms of your choice that, taken\n
+together, effectively do not restrict modification of the portions of the\n
+Library contained in the Combined Work and reverse engineering for debugging\n
+such modifications, if you also do each of the following:\n
+\n
+    a) Give prominent notice with each copy of the Combined Work that the\n
+      Library is used in it and that the Library and its use are covered by\n
+      this License.\n
+    b) Accompany the Combined Work with a copy of the GNU GPL and this\n
+       license document.\n
+    c) For a Combined Work that displays copyright notices during execution,\n
+       include the copyright notice for the Library among these notices,\n
+       as well as a reference directing the user to the copies of the\n
+       GNU GPL and this license document.\n
+    d) Do one of the following:\n
+\n
+        0) Convey the Minimal Corresponding Source under the terms of\n
+           this License, and the Corresponding Application Code in a form\n
+           suitable for, and under terms that permit, the user to recombine\n
+           or relink the Application with a modified version of the Linked\n
+           Version to produce a modified Combined Work, in the manner\n
+           specified by section 6 of the GNU GPL for conveying Corresponding\n
+           Source.\n
+        1) Use a suitable shared library mechanism for linking with the Library.\n
+           A suitable mechanism is one that (a) uses at run time a copy of\n
+           the Library already present on the user's computer system, and\n
+           (b) will operate properly with a modified version of the Library\n
+           that is interface-compatible with the Linked Version.\n
+\n
+    e) Provide Installation Information, but only if you would otherwise\n
+       be required to provide such information under section 6 of the\n
+       GNU GPL, and only to the extent that such information is necessary\n
+       to install and execute a modified version of the Combined Work\n
+       produced by recombining or relinking the Application with a\n
+       modified version of the Linked Version. (If you use option 4d0, the\n
+       Installation Information must accompany the Minimal Corresponding\n
+       Source and Corresponding Application Code. If you use option 4d1,\n
+       you must provide the Installation Information in the manner\n
+       specified by section 6 of the GNU GPL for conveying Corresponding\n
+       Source.)\n
+\n
+5. Combined Libraries.\n
+\n
+You may place library facilities that are a work based on the Library\n
+side by side in a single library together with other library facilities\n
+that are not Applications and are not covered by this License, and convey\n
+such a combined library under terms of your choice, if you do both of the\n
+following:\n
+\n
+    a) Accompany the combined library with a copy of the same work based\n
+       on the Library, uncombined with any other library facilities,\n
+       conveyed under the terms of this License.\n
+    b) Give prominent notice with the combined library that part of it\n
+       is a work based on the Library, and explaining where to find the\n
+       accompanying uncombined form of the same work.\n
+\n
+6. Revised Versions of the GNU Lesser General Public License.\n
+\n
+The Free Software Foundation may publish revised and/or new versions of\n
+the GNU Lesser General Public License from time to time. Such new\n
+versions will be similar in spirit to the present version, but may\n
+differ in detail to address new problems or concerns.\n
+\n
+Each version is given a distinguishing version number. If the Library\n
+as you received it specifies that a certain numbered version of the\n
+GNU Lesser General Public License “or any later version” applies to\n
+it, you have the option of following the terms and conditions either\n
+of that published version or of any later version published by the Free\n
+Software Foundation. If the Library as you received it does not specify\n
+a version number of the GNU Lesser General Public License, you may\n
+choose any version of the GNU Lesser General Public License ever\n
+published by the Free Software Foundation.\n
+\n
+If the Library as you received it specifies that a proxy can decide\n
+whether future versions of the GNU Lesser General Public License shall\n
+apply, that proxy's public statement of acceptance of any version is\n
+permanent authorization for you to choose that version for the Library.\n"
+
+# readans prompt default
+
+function readans () {
+    echo -n "$1 ($2): "
+    IFS='@' read ans || exit 1
+    [ -z "$ans" ] && ans=$2
+}
+
+# readyn prompt default
+
+function readyn () {
+    while :; do
+        readans "$1 [Y/N]" $2
+        case "$ans" in
+        [yY] | [yY]es )
+            ans=y
+            break ;;
+        [nN] | [nN]o )
+            ans=n
+            break ;;
+        * )
+            echo "Please answer Y or N"
+            ;;
+        esac
+    done
+}
+
+# Get the single, required command line argument
+
+nuttx_path=$1
+if [ -z "${nuttx_path}" ]; then
+  echo "ERROR: Missing path to the NuttX directory"
+  echo $usage
+  exit 1
+fi
+
+# Lots of sanity checking so that we do not do anything too stupid
+
+if [ ! -d libxx ]; then
+  echo "ERROR: Directory libxx does not exist in this directory"
+  echo "       Please CD into the misc/uClibc++ directory and try again"
+  echo $usage
+  exit 1
+fi
+
+if [ ! -d include ]; then
+  echo "ERROR: Directory include does not exist in this directory"
+  echo "       Please CD into the misc/uClibc++ directory and try again"
+  echo $usage
+  exit 1
+fi
+
+if [ ! -d "${nuttx_path}" ]; then
+  echo "ERROR: Directory ${nuttx_path} does not exist"
+  echo $usage
+  exit 1
+fi
+
+if [ ! -f "${nuttx_path}/Makefile" ]; then
+  echo "ERROR: Not Makefile in directory ${nuttx_path}"
+  echo $usage
+  exit 1
+fi
+
+libxx_srcdir=${nuttx_path}/libxx
+
+if [ ! -d "${libxx_srcdir}" ]; then
+  echo "ERROR: Directory ${libxx_srcdir} does not exist"
+  echo $usage
+  exit 1
+fi
+
+if [ ! -f "${libxx_srcdir}/Makefile" ]; then
+  echo "ERROR: No Makefile in directory ${libxx_srcdir}"
+  echo $usage
+  exit 1
+fi
+
+uclibc_srcdir=${libxx_srcdir}/uClibc++
+
+if [ -d "${uclibc_srcdir}" ]; then
+  echo "ERROR: Directory ${uclibc_srcdir} already exists"
+  echo "       Please remove the  ${uclibc_srcdir} directory and try again"
+  echo $usage
+  exit 1
+fi
+
+nuttx_incdir=${nuttx_path}/include
+
+if [ ! -d "${nuttx_incdir}" ]; then
+  echo "ERROR: Directory ${nuttx_incdir} does not exist"
+  echo $usage
+  exit 1
+fi
+
+nuttxcxx_incdir=${nuttx_incdir}/cxx
+
+if [ ! -d "${nuttxcxx_incdir}" ]; then
+  echo "ERROR: Directory ${nuttxcxx_incdir} does not exist"
+  echo $usage
+  exit 1
+fi
+
+# Licensing
+
+echo "You are about to install the uClibc++ library into the NuttX source"
+echo "tree.  NuttX is licensed under a modified BSD License; uClibc is"
+echo "licensed under the GNU LGPL Version 3 license.  When you install"
+echo "uClibc++ into the NuttX source tree, you must then comply with uClibc's"
+echo "stricter GNU LGPL Version 3 license."
+echo ""
+
+readyn "Continue" "N"
+echo ""
+
+if [ "X${ans}" != "Xy" -a "X${ans}" != "XY" ]; then
+  echo "Good bye"
+  exit 0
+fi
+
+echo "You must read and agree to the following license"
+echo ""
+
+readyn "Continue" "N"
+echo ""
+
+if [ "X${ans}" != "Xy" -a "X${ans}" != "XY" ]; then
+  echo "Good bye"
+  exit 0
+fi
+
+echo -e ${lgpl} | more
+echo ""
+
+readyn "I agree to the termso the GNU LGPL Version 3 license" "N"
+echo ""
+
+if [ "X${ans}" != "Xy" -a "X${ans}" != "XY" ]; then
+  echo "Good bye"
+  exit 0
+fi
+
+echo "Installing uClibc++ in the NuttX source tree"
+
+cp -a ./libxx/* ${libxx_srcdir}/. ||
+  { echo "Copy from ./libxx/* to ${libxx_srcdir}/. failed"; exit 1; }
+
+cp -a ./include/* ${nuttx_incdir}/. ||
+  { echo "Copy from ./include/* ${nuttx_incdir}/. failed"; exit 1; }
+
+echo "Installation suceeded"
+echo ""

misc/uClibc++/libxx/uClib++/Make.defs

@@ -0,0 +1,52 @@
+############################################################################
+# misc/uClibc++/libxx/uClibc++/Makefile
+#
+#   Copyright (C) 2012 Gregory Nutt. All rights reserved.
+#   Author: Gregory Nutt <spudmonkey@racsa.co.cr>
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions
+# are met:
+#
+# 1. Redistributions of source code must retain the above copyright
+#    notice, this list of conditions and the following disclaimer.
+# 2. Redistributions in binary form must reproduce the above copyright
+#    notice, this list of conditions and the following disclaimer in
+#    the documentation and/or other materials provided with the
+#    distribution.
+# 3. Neither the name NuttX nor the names of its contributors may be
+#    used to endorse or promote products derived from this software
+#    without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+# OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+# AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+#
+###########################################################################
+
+# Add the uClibc++ sources
+
+CXXSRCS += algorithm.cxx associative_base.cxx bitset.cxx char_traits.cxx
+CXXSRCS += complex.cxx del_op.cxx del_opnt.cxx del_opv.cxx del_opvnt.cxx
+CXXSRCS += deque.cxx eh_alloc.cxx eh_globals.cxx exception.cxx
+CXXSRCS += stream.cxx func_exception.cxx iomanip.cxx ios.cxx
+CXXSRCS += iostream.cxx istream.cxx iterator.cxx limits.cxx list.cxx
+CXXSRCS += locale.cxx map.cxx new_handler.cxx new_op.cxx new_opnt.cxx
+CXXSRCS += new_opv.cxx new_opvnt.cxx numeric.cxx ostream.cxx queue.cxx
+CXXSRCS += set.cxx sstream.cxx stack.cxx stdexcept.cxx streambuf.cxx
+CXXSRCS += string.cxx support.cxx typeinfo.cxx utility.cxx valarray.cxx
+CXXSRCS += vector.cxx
+
+# Add the path to the uClibc++ subdirectory
+
+DEPPATH += --dep-path .
+VPATH += uClibc++

misc/uClibc++/libxx/uClib++/algorithm.cxx

@@ -0,0 +1,30 @@
+/*	Copyright (C) 2004 Garrett A. Kajmowicz
+	This file is part of the uClibc++ Library.
+
+	This library is free software; you can redistribute it and/or
+	modify it under the terms of the GNU Lesser General Public
+	License as published by the Free Software Foundation; either
+	version 2.1 of the License, or (at your option) any later version.
+
+	This library is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+	Lesser General Public License for more details.
+
+	You should have received a copy of the GNU Lesser General Public
+	License along with this library; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+*/
+
+
+#include <algorithm>
+
+
+namespace std{
+
+
+
+}
+
+

misc/uClibc++/libxx/uClib++/associative_base.cxx

@@ -0,0 +1,26 @@
+/*	Copyright (C) 2007 Garrett A. Kajmowicz
+	This file is part of the uClibc++ Library.
+
+	This library is free software; you can redistribute it and/or
+	modify it under the terms of the GNU Lesser General Public
+	License as published by the Free Software Foundation; either
+	version 2.1 of the License, or (at your option) any later version.
+
+	This library is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+	Lesser General Public License for more details.
+
+	You should have received a copy of the GNU Lesser General Public
+	License along with this library; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+*/
+
+#include <associative_base>
+
+namespace std{
+
+
+
+}

misc/uClibc++/libxx/uClib++/bitset.cxx

@@ -0,0 +1,26 @@
+/*	Copyright (C) 2004 Garrett A. Kajmowicz
+	This file is part of the uClibc++ Library.
+
+	This library is free software; you can redistribute it and/or
+	modify it under the terms of the GNU Lesser General Public
+	License as published by the Free Software Foundation; either
+	version 2.1 of the License, or (at your option) any later version.
+
+	This library is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+	Lesser General Public License for more details.
+
+	You should have received a copy of the GNU Lesser General Public
+	License along with this library; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+*/
+
+#include <bitset>
+
+namespace std{
+
+
+
+}

misc/uClibc++/libxx/uClib++/char_traits.cxx

@@ -0,0 +1,69 @@
+/*	Copyright (C) 2004 Garrett A. Kajmowicz
+
+	This file is part of the uClibc++ Library.
+
+	This library is free software; you can redistribute it and/or
+	modify it under the terms of the GNU Lesser General Public
+	License as published by the Free Software Foundation; either
+	version 2.1 of the License, or (at your option) any later version.
+
+	This library is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+	Lesser General Public License for more details.
+
+	You should have received a copy of the GNU Lesser General Public
+	License along with this library; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+*/
+
+#define __UCLIBCXX_COMPILE_CHAR_TRAITS__ 1
+
+
+#include <basic_definitions>
+#include <char_traits>
+
+namespace std{
+
+_UCXXEXPORT const char_traits<char>::char_type* char_traits<char>::find(const char_type* s, int n, const char_type& a){
+	for(int i=0; i < n; i++){
+		if(eq(s[i], a)){
+			return (s+i);
+		}
+	}
+	return 0;
+}
+
+_UCXXEXPORT bool char_traits<char>::eq(const char_type& c1, const char_type& c2){
+	if(strncmp(&c1, &c2, 1) == 0){
+		return true;
+	}
+	return false;
+}
+
+_UCXXEXPORT char_traits<char>::char_type char_traits<char>::to_char_type(const int_type & i){
+	if(i > 0 && i <= 255){
+		return (char)(unsigned char)i;
+	}
+
+	//Out of range
+	return 0;
+}
+
+
+
+#ifdef __UCLIBCXX_HAS_WCHAR__
+
+_UCXXEXPORT const char_traits<wchar_t>::char_type* char_traits<wchar_t>::find(const char_type* s, int n, const char_type& a){
+	for(int i=0; i < n; i++){
+		if(eq(s[i], a)){
+			return (s+i);
+		}
+	}
+	return 0;
+}
+
+#endif
+
+}

misc/uClibc++/libxx/uClib++/complex.cxx

@@ -0,0 +1,28 @@
+/*      Copyright (C) 2005 Garrett A. Kajmowicz
+	This file is part of the uClibc++ Library.
+
+	This library is free software; you can redistribute it and/or
+	modify it under the terms of the GNU Lesser General Public
+	License as published by the Free Software Foundation; either
+	version 2.1 of the License, or (at your option) any later version.
+
+	This library is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+	Lesser General Public License for more details.
+
+	You should have received a copy of the GNU Lesser General Public
+	License along with this library; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+#include <complex>
+
+
+namespace std{
+
+
+	template class _UCXXEXPORT complex<float>;
+
+
+}

misc/uClibc++/libxx/uClib++/del_op.cxx

@@ -0,0 +1,26 @@
+/*	Copyright (C) 2004 Garrett A. Kajmowicz
+
+	This file is part of the uClibc++ Library.
+
+	This library is free software; you can redistribute it and/or
+	modify it under the terms of the GNU Lesser General Public
+	License as published by the Free Software Foundation; either
+	version 2.1 of the License, or (at your option) any later version.
+
+	This library is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+	Lesser General Public License for more details.
+
+	You should have received a copy of the GNU Lesser General Public
+	License along with this library; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+#include <new>
+#include <cstdlib>
+#include <func_exception>
+
+_UCXXEXPORT void operator delete(void* ptr) throw(){
+	free(ptr);
+}

misc/uClibc++/libxx/uClib++/del_opnt.cxx

@@ -0,0 +1,28 @@
+/*	Copyright (C) 2004 Garrett A. Kajmowicz
+
+	This file is part of the uClibc++ Library.
+
+	This library is free software; you can redistribute it and/or
+	modify it under the terms of the GNU Lesser General Public
+	License as published by the Free Software Foundation; either
+	version 2.1 of the License, or (at your option) any later version.
+
+	This library is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+	Lesser General Public License for more details.
+
+	You should have received a copy of the GNU Lesser General Public
+	License along with this library; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+#include <new>
+#include <cstdlib>
+#include <func_exception>
+
+#ifndef NO_NOTHROW
+_UCXXEXPORT void operator delete(void* ptr, const std::nothrow_t& ) throw() {
+	free(ptr);
+}
+#endif

misc/uClibc++/libxx/uClib++/del_opv.cxx

@@ -0,0 +1,26 @@
+/*	Copyright (C) 2004 Garrett A. Kajmowicz
+
+	This file is part of the uClibc++ Library.
+
+	This library is free software; you can redistribute it and/or
+	modify it under the terms of the GNU Lesser General Public
+	License as published by the Free Software Foundation; either
+	version 2.1 of the License, or (at your option) any later version.
+
+	This library is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+	Lesser General Public License for more details.
+
+	You should have received a copy of the GNU Lesser General Public
+	License along with this library; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+#include <new>
+#include <cstdlib>
+#include <func_exception>
+
+_UCXXEXPORT void operator delete[](void * ptr) throw(){
+	free(ptr);
+}

misc/uClibc++/libxx/uClib++/del_opvnt.cxx

@@ -0,0 +1,28 @@
+/*	Copyright (C) 2004 Garrett A. Kajmowicz
+
+	This file is part of the uClibc++ Library.
+
+	This library is free software; you can redistribute it and/or
+	modify it under the terms of the GNU Lesser General Public
+	License as published by the Free Software Foundation; either
+	version 2.1 of the License, or (at your option) any later version.
+
+	This library is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+	Lesser General Public License for more details.
+
+	You should have received a copy of the GNU Lesser General Public
+	License along with this library; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+#include <new>
+#include <cstdlib>
+#include <func_exception>
+
+#ifndef NO_NOTHROW
+_UCXXEXPORT void operator delete[](void* ptr, const std::nothrow_t& ) throw(){
+	free(ptr);
+}
+#endif

misc/uClibc++/libxx/uClib++/deque.cxx

@@ -0,0 +1,42 @@
+/*	Copyright (C) 2004 Garrett A. Kajmowicz
+	This file is part of the uClibc++ Library.
+
+	This library is free software; you can redistribute it and/or
+	modify it under the terms of the GNU Lesser General Public
+	License as published by the Free Software Foundation; either
+	version 2.1 of the License, or (at your option) any later version.
+
+	This library is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+	Lesser General Public License for more details.
+
+	You should have received a copy of the GNU Lesser General Public
+	License along with this library; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+*/
+
+#include <deque>
+
+
+namespace std{
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+}
+
+
+
+

misc/uClibc++/libxx/uClib++/eh_alloc.cxx

@@ -0,0 +1,61 @@
+/*	Copyright (C) 2006 Garrett A. Kajmowicz
+
+	This file is part of the uClibc++ Library.
+
+	This library is free software; you can redistribute it and/or
+	modify it under the terms of the GNU Lesser General Public
+	License as published by the Free Software Foundation, version 2.1
+	of the License.
+
+	This library is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+	Lesser General Public License for more details.
+
+	You should have received a copy of the GNU Lesser General Public
+	License along with this library; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+#include <cstdlib>
+#include <cstring>
+#include <func_exception>
+
+//This is a system-specific header which does all of the error-handling management
+#include <unwind-cxx.h>
+
+namespace __cxxabiv1{
+
+extern "C" void * __cxa_allocate_exception(std::size_t thrown_size) throw(){
+	void *retval;
+	//The sizeof crap is required by Itanium ABI because we need to provide space for
+	//accounting information which is implementaion (gcc) specified
+	retval = malloc (thrown_size + sizeof(__cxa_exception));
+	if (0 == retval){
+		std::terminate();
+	}
+	memset (retval, 0, sizeof(__cxa_exception));
+	return (void *)((unsigned char *)retval + sizeof(__cxa_exception));
+}
+
+extern "C" void __cxa_free_exception(void *vptr) throw(){
+	free( (char *)(vptr) - sizeof(__cxa_exception) );
+}
+
+
+extern "C" __cxa_dependent_exception * __cxa_allocate_dependent_exception() throw(){
+	__cxa_dependent_exception *retval;
+	//The sizeof crap is required by Itanium ABI because we need to provide space for
+	//accounting information which is implementaion (gcc) specified
+	retval = static_cast<__cxa_dependent_exception*>(malloc (sizeof(__cxa_dependent_exception)));
+	if (0 == retval){
+		std::terminate();
+	}
+	memset (retval, 0, sizeof(__cxa_dependent_exception));
+	return retval;
+}
+
+extern "C" void __cxa_free_dependent_exception(__cxa_dependent_exception *vptr) throw(){
+	free( (char *)(vptr) );
+}
+}

misc/uClibc++/libxx/uClib++/eh_globals.cxx

@@ -0,0 +1,42 @@
+/*	Copyright (C) 2006 Garrett A. Kajmowicz
+
+	This file is part of the uClibc++ Library.
+
+	This library is free software; you can redistribute it and/or
+	modify it under the terms of the GNU Lesser General Public
+	License as published by the Free Software Foundation, version 2.1
+	of the License.
+
+	This library is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+	Lesser General Public License for more details.
+
+	You should have received a copy of the GNU Lesser General Public
+	License along with this library; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+#include <cstdlib>
+#include <cstring>
+#include <func_exception>
+
+//This is a system-specific header which does all of the error-handling management
+#include <unwind-cxx.h>
+
+//The following functionality is derived from reading of the GNU libstdc++ code and making it...simple
+
+
+namespace __cxxabiv1{
+
+static __UCLIBCXX_TLS __cxa_eh_globals eh_globals;
+
+extern "C" __cxa_eh_globals* __cxa_get_globals() throw(){
+	return &eh_globals;
+}
+
+extern "C" __cxa_eh_globals* __cxa_get_globals_fast() throw(){
+	return &eh_globals;
+}
+
+}

misc/uClibc++/libxx/uClib++/exception.cxx

@@ -0,0 +1,52 @@
+/*	Copyright (C) 2004 Garrett A. Kajmowicz
+
+	This file is part of the uClibc++ Library.
+
+	This library is free software; you can redistribute it and/or
+	modify it under the terms of the GNU Lesser General Public
+	License as published by the Free Software Foundation; either
+	version 2.1 of the License, or (at your option) any later version.
+
+	This library is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+	Lesser General Public License for more details.
+
+	You should have received a copy of the GNU Lesser General Public
+	License along with this library; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+*/
+
+#include <exception>
+
+//We can't do this yet because gcc is too stupid to be able to handle
+//different implementations of exception class.
+
+#undef __UCLIBCXX_EXCEPTION_SUPPORT__
+
+#ifdef __UCLIBCXX_EXCEPTION_SUPPORT__
+
+namespace std{
+	_UCXXEXPORT static char * __std_exception_what_value = "exception";
+
+	//We are providing our own versions to be sneaky
+
+
+	_UCXXEXPORT exception::~exception() throw(){
+		//Empty function
+	}
+
+	_UCXXEXPORT const char* exception::what() const throw(){
+		return __std_exception_what_value;
+	}
+
+	_UCXXEXPORT bad_exception::~bad_exception() throw(){
+
+	}
+
+
+}
+
+
+#endif

misc/uClibc++/libxx/uClib++/fstream.cxx

@@ -0,0 +1,174 @@
+/*	Copyright (C) 2004 Garrett A. Kajmowicz
+
+	This file is part of the uClibc++ Library.
+
+	This library is free software; you can redistribute it and/or
+	modify it under the terms of the GNU Lesser General Public
+	License as published by the Free Software Foundation; either
+	version 2.1 of the License, or (at your option) any later version.
+
+	This library is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+	Lesser General Public License for more details.
+
+	You should have received a copy of the GNU Lesser General Public
+	License along with this library; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+#define __UCLIBCXX_COMPILE_FSTREAM__ 1
+
+#include <fstream>
+
+namespace std{
+
+#ifdef __UCLIBCXX_EXPAND_FSTREAM_CHAR__
+
+#ifdef __UCLIBCXX_EXPAND_CONSTRUCTORS_DESTRUCTORS__
+
+	template _UCXXEXPORT filebuf::basic_filebuf();
+	template _UCXXEXPORT filebuf::~basic_filebuf();
+
+#endif //__UCLIBCXX_EXPAND_CONSTRUCTORS_DESTRUCTORS__
+
+	template _UCXXEXPORT filebuf::int_type filebuf::pbackfail(filebuf::int_type c);
+	template _UCXXEXPORT filebuf * filebuf::open(const char* s, ios_base::openmode mode);
+	template _UCXXEXPORT filebuf * filebuf::close();
+	template _UCXXEXPORT filebuf::int_type filebuf::overflow(filebuf::int_type);
+	template _UCXXEXPORT filebuf::int_type filebuf::underflow ();
+	template _UCXXEXPORT streamsize filebuf::xsputn(const char* s, streamsize n);
+
+	template _UCXXEXPORT basic_streambuf<char, char_traits<char> >*
+		filebuf::setbuf(char * s, streamsize n);
+
+
+#ifdef __UCLIBCXX_EXPAND_CONSTRUCTORS_DESTRUCTORS__
+
+	template _UCXXEXPORT basic_ofstream<char, char_traits<char> >::basic_ofstream();
+	template _UCXXEXPORT basic_ofstream<char, char_traits<char> >::basic_ofstream(const char* s, ios_base::openmode mode);
+	template _UCXXEXPORT basic_ofstream<char, char_traits<char> >::~basic_ofstream();
+
+	template _UCXXEXPORT basic_ifstream<char, char_traits<char> >::basic_ifstream();
+	template _UCXXEXPORT basic_ifstream<char, char_traits<char> >::basic_ifstream(const char* s, ios_base::openmode mode);
+	template _UCXXEXPORT basic_ifstream<char, char_traits<char> >::~basic_ifstream();
+
+#endif //__UCLIBCXX_EXPAND_CONSTRUCTORS_DESTRUCTORS__
+
+
+#endif
+
+
+
+#ifdef __UCLIBCXX_HAS_WCHAR__
+
+template <> _UCXXEXPORT basic_filebuf<wchar_t, char_traits<wchar_t> >::int_type
+	basic_filebuf<wchar_t, char_traits<wchar_t> >::overflow(int_type c)
+{
+	typedef basic_streambuf<wchar_t, char_traits<wchar_t> > wstreambuf;
+	typedef char_traits<wchar_t> wtraits;
+
+	if(is_open() == false){
+		//Can't do much
+		return wtraits::eof();
+	}
+
+	mbstate_t ps = { 0 };
+	char out_array[8];
+	size_t out_size;
+
+
+	if( wstreambuf::pbase() != 0 ){
+
+		//Write all possible character from the existing array first
+		size_t chars_written = 0;
+		while(wstreambuf::pbase() && (wstreambuf::pbase() + chars_written !=wstreambuf::pptr()) ){
+			out_size = wcrtomb(out_array, wstreambuf::pbase()[chars_written], &ps);
+			if(out_size == (size_t)(-1) || fwrite(out_array, out_size, 1, fp) == 0){
+				break;
+			}
+			++chars_written;
+		}
+
+		if( wstreambuf::pbase() + chars_written == wstreambuf::pptr() ){
+			wstreambuf::pbump(-chars_written);
+		}else{
+			//Shuffle data back into order
+			size_t chars_left = wstreambuf::pptr() - wstreambuf::pbase() - chars_written;
+			for(size_t i = 0; i < chars_left; ++i){
+				wstreambuf::pbase()[i] = (wstreambuf::pptr() - chars_written)[i];
+			}
+			return wtraits::eof();
+		}
+	}
+
+	if( !wtraits::eq_int_type(c, wtraits::eof()) ){
+		out_size = wcrtomb(out_array, c, &ps);
+		if(out_size == (size_t)(-1) || fwrite(out_array, out_size, 1, fp) == 0){
+			return wtraits::eof();
+		}
+		return c;
+	}
+
+	return wtraits::not_eof(c);
+}
+
+
+template <> _UCXXEXPORT basic_filebuf<wchar_t, char_traits<wchar_t> >::int_type
+        basic_filebuf<wchar_t, char_traits<wchar_t> >::underflow()
+{
+	/*Some variables used internally:
+	Buffer pointers:
+
+	charT * mgbeg;
+	charT * mgnext;
+	charT * mgend;
+
+	eback() returns mgbeg
+	gptr()  returns mgnext
+	egptr() returns mgend
+
+	gbump(int n) mgnext+=n
+	*/
+
+	typedef char_traits<wchar_t> traits;
+	typedef basic_streambuf<wchar_t, traits> wstreambuf;
+
+
+	if(wstreambuf::eback() == wstreambuf::gptr() && 0 != wstreambuf::eback()){	//Buffer is full
+		return traits::to_int_type(*wstreambuf::gptr());
+	}
+
+        size_t in_size;
+
+	wchar_t c = 0;
+	wint_t wi = 0;
+	in_size = 0;
+
+	wi = fgetwc(fp);
+	if(WEOF == wi){
+		fprintf(stderr, "WEOF returned by fgetwc\n");
+		return traits::eof();
+	}
+
+	c = traits::to_char_type(wi);
+
+	if(wstreambuf::eback() == 0){
+		return traits::to_int_type(c);
+	}
+
+	for(wchar_t * i = wstreambuf::gptr(); i < wstreambuf::egptr(); ++i){
+		*(i-1) = *i;
+	}
+
+	*(wstreambuf::egptr()-1) = c;
+	
+	wstreambuf::mgnext -= 1;
+
+	return traits::to_int_type(*wstreambuf::gptr());
+}
+
+#endif // __UCLIBCXX_HAS_WCHAR__
+
+
+}

misc/uClibc++/libxx/uClib++/func_exception.cxx

@@ -0,0 +1,87 @@
+/*	Copyright (C) 2004 Garrett A. Kajmowicz
+
+	This file is part of the uClibc++ Library.
+
+	This library is free software; you can redistribute it and/or
+	modify it under the terms of the GNU Lesser General Public
+	License as published by the Free Software Foundation; either
+	version 2.1 of the License, or (at your option) any later version.
+
+	This library is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+	Lesser General Public License for more details.
+
+	You should have received a copy of the GNU Lesser General Public
+	License along with this library; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+#include <exception>
+#include <func_exception>
+#include <stdexcept>
+#include <cstdlib>
+
+namespace std{
+
+#ifdef __UCLIBCXX_EXCEPTION_SUPPORT__
+
+_UCXXEXPORT void __throw_bad_alloc(){
+	throw bad_alloc();
+}
+
+_UCXXEXPORT void __throw_out_of_range( const char * message){
+	if(message == 0){
+		throw out_of_range();
+	}
+	throw out_of_range(message);
+}
+
+_UCXXEXPORT void __throw_overflow_error( const char * message){
+	if(message == 0){
+		throw overflow_error();
+	}
+	throw overflow_error(message);
+}
+
+_UCXXEXPORT void __throw_length_error(const char * message){
+	if(message == 0){
+		throw length_error();
+	}
+	throw length_error(message);
+}
+
+_UCXXEXPORT void __throw_invalid_argument(const char * message){
+	if(message == 0){
+		throw invalid_argument();
+	}
+	throw invalid_argument(message);
+}
+
+#else
+
+_UCXXEXPORT void __throw_bad_alloc(){
+	abort();
+}
+
+_UCXXEXPORT void __throw_out_of_range( const char * ){
+	abort();
+}
+
+_UCXXEXPORT void __throw_overflow_error( const char * ){
+	abort();
+}
+
+_UCXXEXPORT void __throw_length_error(const char * ){
+	abort();
+}
+
+_UCXXEXPORT void __throw_invalid_argument(const char *){
+	abort();
+}
+
+#endif
+
+
+
+}

misc/uClibc++/libxx/uClib++/iomanip.cxx

@@ -0,0 +1,29 @@
+/*	Copyright (C) 2005 Garrett A. Kajmowicz
+
+	This file is part of the uClibc++ Library.
+
+	This library is free software; you can redistribute it and/or
+	modify it under the terms of the GNU Lesser General Public
+	License as published by the Free Software Foundation; either
+	version 2.1 of the License, or (at your option) any later version.
+
+	This library is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+	Lesser General Public License for more details.
+
+	You should have received a copy of the GNU Lesser General Public
+	License along with this library; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+#include <iomanip>
+
+namespace std{
+
+
+
+
+}
+
+

misc/uClibc++/libxx/uClib++/ios.cxx

@@ -0,0 +1,189 @@
+/*	Copyright (C) 2004 Garrett A. Kajmowicz
+
+	This file is part of the uClibc++ Library.
+
+	This library is free software; you can redistribute it and/or
+	modify it under the terms of the GNU Lesser General Public
+	License as published by the Free Software Foundation; either
+	version 2.1 of the License, or (at your option) any later version.
+
+	This library is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+	Lesser General Public License for more details.
+
+	You should have received a copy of the GNU Lesser General Public
+	License along with this library; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+#define __UCLIBCXX_COMPILE_IOS__ 1
+
+#include <ios>
+#include <ostream>
+#include <istream>
+#include <cstdio>
+#include <fstream>
+
+namespace std{
+
+
+#ifdef __UCLIBCXX_SUPPORT_CDIR__
+	_UCXXLOCAL int ios_base::Init::init_cnt = 0;	//Needed to ensure the static value is created
+
+//Create buffers first
+#ifdef __UCLIBCXX_SUPPORT_COUT__
+	_UCXXEXPORT filebuf _cout_filebuf;
+#endif
+#ifdef __UCLIBCXX_SUPPORT_CIN__
+	_UCXXEXPORT filebuf _cin_filebuf;
+#endif
+#ifdef __UCLIBCXX_SUPPORT_CERR__
+	_UCXXEXPORT filebuf _cerr_filebuf;
+#endif
+#ifdef __UCLIBCXX_SUPPORT_CLOG__
+	_UCXXEXPORT filebuf _clog_filebuf;
+#endif
+#ifdef __UCLIBCXX_SUPPORT_WCOUT__
+	_UCXXEXPORT wfilebuf _wcout_filebuf;
+#endif
+#ifdef __UCLIBCXX_SUPPORT_WCIN__
+	_UCXXEXPORT wfilebuf _wcin_filebuf;
+#endif
+#ifdef __UCLIBCXX_SUPPORT_WCERR__
+	_UCXXEXPORT wfilebuf _wcerr_filebuf;
+#endif
+#ifdef __UCLIBCXX_SUPPORT_WCLOG__
+	_UCXXEXPORT wfilebuf _wclog_filebuf;
+#endif
+
+//Then create streams
+#ifdef __UCLIBCXX_SUPPORT_COUT__
+	_UCXXEXPORT ostream cout(&_cout_filebuf);
+#endif
+#ifdef __UCLIBCXX_SUPPORT_CIN__
+	_UCXXEXPORT istream cin(&_cin_filebuf);
+#endif
+#ifdef __UCLIBCXX_SUPPORT_CERR__
+	_UCXXEXPORT ostream cerr(&_cerr_filebuf);
+#endif
+#ifdef __UCLIBCXX_SUPPORT_CLOG__
+	_UCXXEXPORT ostream clog(&_clog_filebuf);
+#endif
+#ifdef __UCLIBCXX_SUPPORT_WCOUT__
+	_UCXXEXPORT wostream wcout(&_wcout_filebuf);
+#endif
+#ifdef __UCLIBCXX_SUPPORT_WCIN__
+	_UCXXEXPORT wistream wcin(&_wcin_filebuf);
+#endif
+#ifdef __UCLIBCXX_SUPPORT_WCERR__
+	_UCXXEXPORT wostream wcerr(&_wcerr_filebuf);
+#endif
+#ifdef __UCLIBCXX_SUPPORT_WCLOG__
+	_UCXXEXPORT wostream wclog(&_wclog_filebuf);
+#endif
+
+
+	_UCXXEXPORT ios_base::Init::Init(){
+		if(init_cnt == 0){	//Need to construct cout et al
+#ifdef __UCLIBCXX_SUPPORT_COUT__
+			_cout_filebuf.fp = stdout;
+			_cout_filebuf.openedFor = ios_base::out;
+#endif
+#ifdef __UCLIBCXX_SUPPORT_CERR__
+			_cerr_filebuf.fp = stderr;
+			_cerr_filebuf.openedFor = ios_base::out;
+			cerr.mformat |= ios_base::unitbuf;
+#endif
+#ifdef __UCLIBCXX_SUPPORT_CLOG__
+			_clog_filebuf.fp = stderr;
+			_clog_filebuf.openedFor = ios_base::out;
+#endif
+#ifdef __UCLIBCXX_SUPPORT_CIN__
+			_cin_filebuf.fp = stdin;
+			_cin_filebuf.openedFor = ios_base::in;
+
+#ifdef __UCLIBCXX_SUPPORT_COUT__
+			cin.tie(&cout);
+#endif
+
+#endif
+#ifdef __UCLIBCXX_SUPPORT_WCOUT__
+			_wcout_filebuf.fp = stdout;
+			_wcout_filebuf.openedFor = ios_base::out;
+#endif
+#ifdef __UCLIBCXX_SUPPORT_WCERR__
+			_wcerr_filebuf.fp = stderr;
+			_wcerr_filebuf.openedFor = ios_base::out;
+			wcerr.mformat |= ios_base::unitbuf;
+#endif
+#ifdef __UCLIBCXX_SUPPORT_WCLOG__
+			_wclog_filebuf.fp = stderr;
+			_wclog_filebuf.openedFor = ios_base::out;
+#endif
+#ifdef __UCLIBCXX_SUPPORT_WCIN__
+			_wcin_filebuf.fp = stdin;
+			_wcin_filebuf.openedFor = ios_base::in;
+
+#ifdef __UCLIBCXX_SUPPORT_WCOUT__
+			wcin.tie(&wcout);
+#endif
+
+#endif
+		}
+		init_cnt++;
+	}
+
+	_UCXXEXPORT ios_base::Init::~Init(){
+		--init_cnt;
+		if(init_cnt==0){
+
+		}
+	}
+#endif
+
+
+#ifdef __UCLIBCXX_EXPAND_IOS_CHAR__
+
+	template _UCXXEXPORT void basic_ios<char, char_traits<char> >::clear(iostate state);
+	template _UCXXEXPORT void basic_ios<char, char_traits<char> >::setstate(iostate state);
+
+#endif
+
+
+	_UCXXEXPORT ios_base::fmtflags ios_base::flags(fmtflags fmtfl){
+		fmtflags temp = mformat;
+		mformat = fmtfl;
+		return temp;
+	}
+
+	_UCXXEXPORT ios_base::fmtflags ios_base::setf(fmtflags fmtfl){
+		return flags(flags() | fmtfl);
+	}
+
+	_UCXXEXPORT ios_base::fmtflags ios_base::setf(fmtflags fmtfl, fmtflags mask ){
+		return flags( (flags()& ~mask) | (fmtfl & mask));
+	}
+
+	_UCXXEXPORT streamsize ios_base::precision(streamsize prec){
+		streamsize temp = mprecision;
+		mprecision = prec;
+		return temp;
+	}
+
+	_UCXXEXPORT streamsize ios_base::width(streamsize wide){
+		streamsize temp = mwidth;
+		mwidth = wide;
+		return temp;
+	}
+
+	_UCXXEXPORT locale ios_base::imbue(const locale& loc){
+		locale retval = mLocale;
+		mLocale = loc;
+		return retval;
+	}	
+
+}
+
+
+

misc/uClibc++/libxx/uClib++/iostream.cxx

@@ -0,0 +1,38 @@
+/*	Copyright (C) 2004 Garrett A. Kajmowicz
+
+	This file is part of the uClibc++ Library.
+
+	This library is free software; you can redistribute it and/or
+	modify it under the terms of the GNU Lesser General Public
+	License as published by the Free Software Foundation; either
+	version 2.1 of the License, or (at your option) any later version.
+
+	This library is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+	Lesser General Public License for more details.
+
+	You should have received a copy of the GNU Lesser General Public
+	License along with this library; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+#define __UCLIBCXX_COMPILE_IOSTREAM__ 1
+
+#include <iostream>
+
+namespace std{
+
+#ifdef __UCLIBCXX_EXPAND_OSTREAM_CHAR__
+#ifdef __UCLIBCXX_EXPAND_ISTREAM_CHAR__
+
+	template _UCXXEXPORT basic_iostream<char, char_traits<char> >::
+		basic_iostream(basic_streambuf<char, char_traits<char> >* sb);
+	template _UCXXEXPORT basic_iostream<char, char_traits<char> >::~basic_iostream();
+
+#endif
+#endif
+
+}
+
+

misc/uClibc++/libxx/uClib++/istream.cxx

@@ -0,0 +1,75 @@
+/*	Copyright (C) 2004 Garrett A. Kajmowicz
+
+	This file is part of the uClibc++ Library.
+
+	This library is free software; you can redistribute it and/or
+	modify it under the terms of the GNU Lesser General Public
+	License as published by the Free Software Foundation; either
+	version 2.1 of the License, or (at your option) any later version.
+
+	This library is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+	Lesser General Public License for more details.
+
+	You should have received a copy of the GNU Lesser General Public
+	License along with this library; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+*/
+
+#define __UCLIBCXX_COMPILE_ISTREAM__ 1
+
+#include <istream>
+
+
+namespace std{
+
+#ifdef __UCLIBCXX_EXPAND_ISTREAM_CHAR__
+
+	template <> _UCXXEXPORT string _readToken<char, char_traits<char> >(istream & stream)
+	{
+		string temp;
+		char_traits<char>::int_type c;
+		while(true){
+			c = stream.rdbuf()->sgetc();
+			if(c != char_traits<char>::eof() && isspace(c) == false){
+				stream.rdbuf()->sbumpc();
+				temp.append(1, char_traits<char>::to_char_type(c));
+			}else{
+				break;
+			}
+		}
+		if (temp.size() == 0)
+			stream.setstate(ios_base::eofbit|ios_base::failbit);
+
+		return temp;
+        }
+
+	template _UCXXEXPORT istream::int_type istream::get();
+	template _UCXXEXPORT istream & istream::get(char &c);
+
+	template _UCXXEXPORT istream & istream::operator>>(bool &n);
+	template _UCXXEXPORT istream & istream::operator>>(short &n);
+	template _UCXXEXPORT istream & istream::operator>>(unsigned short &n);
+	template _UCXXEXPORT istream & istream::operator>>(int &n);
+	template _UCXXEXPORT istream & istream::operator>>(unsigned int &n);
+	template _UCXXEXPORT istream & istream::operator>>(long unsigned &n);
+	template _UCXXEXPORT istream & istream::operator>>(long int &n);
+	template _UCXXEXPORT istream & istream::operator>>(void *& p);
+	template _UCXXEXPORT istream & operator>>(istream & is, char & c);
+
+
+#ifdef __UCLIBCXX_HAS_FLOATS__
+	template _UCXXEXPORT istream & istream::operator>>(float &f);
+	template _UCXXEXPORT istream & istream::operator>>(double &f);
+	template _UCXXEXPORT istream & istream::operator>>(long double &f);
+#endif
+
+	template _UCXXEXPORT void __skipws(basic_istream<char, char_traits<char> >& is);
+
+#endif
+
+
+}
+

misc/uClibc++/libxx/uClib++/iterator.cxx

@@ -0,0 +1,28 @@
+/*	Copyright (C) 2004 Garrett A. Kajmowicz
+
+	This file is part of the uClibc++ Library.
+
+	This library is free software; you can redistribute it and/or
+	modify it under the terms of the GNU Lesser General Public
+	License as published by the Free Software Foundation; either
+	version 2.1 of the License, or (at your option) any later version.
+
+	This library is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+	Lesser General Public License for more details.
+
+	You should have received a copy of the GNU Lesser General Public
+	License along with this library; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+#include <iterator>
+
+namespace std{
+
+
+
+}
+
+

misc/uClibc++/libxx/uClib++/limits.cxx

@@ -0,0 +1,25 @@
+/*	Copyright (C) 2006 Garrett A. Kajmowicz
+	This file is part of the uClibc++ Library.
+
+	This library is free software; you can redistribute it and/or
+	modify it under the terms of the GNU Lesser General Public
+	License as published by the Free Software Foundation; either
+	version 2.1 of the License, or (at your option) any later version.
+
+	This library is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+	Lesser General Public License for more details.
+
+	You should have received a copy of the GNU Lesser General Public
+	License along with this library; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+*/
+
+#include <limits>
+
+namespace std{
+
+
+}

misc/uClibc++/libxx/uClib++/list.cxx

@@ -0,0 +1,29 @@
+/*	Copyright (C) 2004 Garrett A. Kajmowicz
+
+	This file is part of the uClibc++ Library.
+
+	This library is free software; you can redistribute it and/or
+	modify it under the terms of the GNU Lesser General Public
+	License as published by the Free Software Foundation; either
+	version 2.1 of the License, or (at your option) any later version.
+
+	This library is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+	Lesser General Public License for more details.
+
+	You should have received a copy of the GNU Lesser General Public
+	License along with this library; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+#include <list>
+
+namespace std{
+
+
+
+
+}
+
+

misc/uClibc++/libxx/uClib++/locale.cxx

@@ -0,0 +1,29 @@
+/*	Copyright (C) 2004 Garrett A. Kajmowicz
+
+	This file is part of the uClibc++ Library. 
+
+	This library is free software; you can redistribute it and/or
+	modify it under the terms of the GNU Lesser General Public
+	License as published by the Free Software Foundation; either
+	version 2.1 of the License, or (at your option) any later version.
+
+	This library is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+	Lesser General Public License for more details.
+
+	You should have received a copy of the GNU Lesser General Public
+	License along with this library; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+#include <locale>
+#include <cstring>
+#include <string>
+#include <stdexcept>
+#include <cctype>
+
+namespace std{
+
+}
+

misc/uClibc++/libxx/uClib++/map.cxx

@@ -0,0 +1,33 @@
+/*	Copyright (C) 2004 Garrett A. Kajmowicz
+	This file is part of the uClibc++ Library.
+
+	This library is free software; you can redistribute it and/or
+	modify it under the terms of the GNU Lesser General Public
+	License as published by the Free Software Foundation; either
+	version 2.1 of the License, or (at your option) any later version.
+
+	This library is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+	Lesser General Public License for more details.
+
+	You should have received a copy of the GNU Lesser General Public
+	License along with this library; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+*/
+
+#include <map>
+
+namespace std{
+
+
+
+
+
+
+
+
+
+
+}

misc/uClibc++/libxx/uClib++/new_handler.cxx

@@ -0,0 +1,31 @@
+/*	Copyright (C) 2005 Garrett A. Kajmowicz
+
+	This file is part of the uClibc++ Library.
+
+	This library is free software; you can redistribute it and/or
+	modify it under the terms of the GNU Lesser General Public
+	License as published by the Free Software Foundation; either
+	version 2.1 of the License, or (at your option) any later version.
+
+	This library is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+	Lesser General Public License for more details.
+
+	You should have received a copy of the GNU Lesser General Public
+	License along with this library; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+#include <new>
+
+const std::nothrow_t std::nothrow = { };
+
+//Name selected to be compatable with g++ code
+std::new_handler __new_handler;
+
+_UCXXEXPORT std::new_handler std::set_new_handler(std::new_handler new_p) throw(){
+	std::new_handler retval = __new_handler;
+	__new_handler = new_p;
+	return retval;
+}

misc/uClibc++/libxx/uClib++/new_op.cxx

@@ -0,0 +1,35 @@
+/*	Copyright (C) 2004 Garrett A. Kajmowicz
+
+	This file is part of the uClibc++ Library.
+
+	This library is free software; you can redistribute it and/or
+	modify it under the terms of the GNU Lesser General Public
+	License as published by the Free Software Foundation; either
+	version 2.1 of the License, or (at your option) any later version.
+
+	This library is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+	Lesser General Public License for more details.
+
+	You should have received a copy of the GNU Lesser General Public
+	License along with this library; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+#include <new>
+#include <cstdlib>
+#include <func_exception>
+
+_UCXXEXPORT void* operator new(std::size_t numBytes) throw(std::bad_alloc){
+	//C++ stardard 5.3.4.8 requires that a valid pointer be returned for
+	//a call to new(0). Thus:
+	if(numBytes == 0){
+		numBytes = 1;
+	}
+	void * p = malloc(numBytes);
+	if(p == 0){
+		std::__throw_bad_alloc();
+	}
+	return p;
+}

misc/uClibc++/libxx/uClib++/new_opnt.cxx

@@ -0,0 +1,28 @@
+/*	Copyright (C) 2004 Garrett A. Kajmowicz
+
+	This file is part of the uClibc++ Library.
+
+	This library is free software; you can redistribute it and/or
+	modify it under the terms of the GNU Lesser General Public
+	License as published by the Free Software Foundation; either
+	version 2.1 of the License, or (at your option) any later version.
+
+	This library is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+	Lesser General Public License for more details.
+
+	You should have received a copy of the GNU Lesser General Public
+	License along with this library; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+#include <new>
+#include <cstdlib>
+#include <func_exception>
+
+#ifndef NO_NOTHROW
+_UCXXEXPORT void* operator new(std::size_t numBytes, const std::nothrow_t& ) throw(){
+	return malloc(numBytes);
+}
+#endif

misc/uClibc++/libxx/uClib++/new_opv.cxx

@@ -0,0 +1,35 @@
+/*	Copyright (C) 2004 Garrett A. Kajmowicz
+
+	This file is part of the uClibc++ Library.
+
+	This library is free software; you can redistribute it and/or
+	modify it under the terms of the GNU Lesser General Public
+	License as published by the Free Software Foundation; either
+	version 2.1 of the License, or (at your option) any later version.
+
+	This library is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+	Lesser General Public License for more details.
+
+	You should have received a copy of the GNU Lesser General Public
+	License along with this library; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+#include <new>
+#include <cstdlib>
+#include <func_exception>
+
+_UCXXEXPORT void* operator new[](std::size_t numBytes) throw(std::bad_alloc){
+	//C++ stardard 5.3.4.8 requires that a valid pointer be returned for
+	//a call to new(0). Thus:
+	if(numBytes == 0){
+		numBytes = 1;
+	}
+	void * p = malloc(numBytes);
+	if(p == 0){
+		std::__throw_bad_alloc();
+	}
+	return p;
+}

misc/uClibc++/libxx/uClib++/new_opvnt.cxx

@@ -0,0 +1,28 @@
+/*	Copyright (C) 2004 Garrett A. Kajmowicz
+
+	This file is part of the uClibc++ Library.
+
+	This library is free software; you can redistribute it and/or
+	modify it under the terms of the GNU Lesser General Public
+	License as published by the Free Software Foundation; either
+	version 2.1 of the License, or (at your option) any later version.
+
+	This library is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+	Lesser General Public License for more details.
+
+	You should have received a copy of the GNU Lesser General Public
+	License along with this library; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+#include <new>
+#include <cstdlib>
+#include <func_exception>
+
+#ifndef NO_NOTHROW
+_UCXXEXPORT void* operator new[](std::size_t numBytes, const std::nothrow_t& ) throw(){
+	return malloc(numBytes);
+}
+#endif

misc/uClibc++/libxx/uClib++/numeric.cxx

@@ -0,0 +1,27 @@
+/*	Copyright (C) 2004 Garrett A. Kajmowicz
+
+	This file is part of the uClibc++ Library.
+
+	This library is free software; you can redistribute it and/or
+	modify it under the terms of the GNU Lesser General Public
+	License as published by the Free Software Foundation; either
+	version 2.1 of the License, or (at your option) any later version.
+
+	This library is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+	Lesser General Public License for more details.
+
+	You should have received a copy of the GNU Lesser General Public
+	License along with this library; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+#include <numeric>
+
+namespace std{
+
+
+}
+
+

misc/uClibc++/libxx/uClib++/ostream.cxx

@@ -0,0 +1,65 @@
+/*	Copyright (C) 2004 Garrett A. Kajmowicz
+
+	This file is part of the uClibc++ Library.
+
+	This library is free software; you can redistribute it and/or
+	modify it under the terms of the GNU Lesser General Public
+	License as published by the Free Software Foundation; either
+	version 2.1 of the License, or (at your option) any later version.
+
+	This library is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+	Lesser General Public License for more details.
+
+	You should have received a copy of the GNU Lesser General Public
+	License along with this library; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+#define __UCLIBCXX_COMPILE_OSTREAM__ 1
+
+#include <ostream>
+
+namespace std{
+	
+
+#ifdef __UCLIBCXX_EXPAND_OSTREAM_CHAR__
+	
+#ifdef __UCLIBCXX_EXPAND_CONSTRUCTORS_DESTRUCTORS__
+	template _UCXXEXPORT ostream::~basic_ostream();
+#endif //__UCLIBCXX_EXPAND_CONSTRUCTORS_DESTRUCTORS__
+
+	template _UCXXEXPORT ostream & ostream::flush();
+
+	template _UCXXEXPORT ostream & ostream::operator<<(bool n);
+	template _UCXXEXPORT ostream & ostream::operator<<(short int n);
+	template _UCXXEXPORT ostream & ostream::operator<<(unsigned short int n);
+	template _UCXXEXPORT ostream & ostream::operator<<(int n);
+	template _UCXXEXPORT ostream & ostream::operator<<(unsigned int n);
+	template _UCXXEXPORT ostream & ostream::operator<<(long n);
+	template _UCXXEXPORT ostream & ostream::operator<<(unsigned long n);
+	template _UCXXEXPORT ostream & ostream::operator<<(float f);
+	template _UCXXEXPORT ostream & ostream::operator<<(double f);
+	template _UCXXEXPORT ostream & ostream::operator<<(long double f);
+	template _UCXXEXPORT ostream & ostream::operator<<(void* p);
+	template _UCXXEXPORT ostream & ostream::operator<<(basic_streambuf<char, char_traits<char> >* sb);
+
+#ifdef __UCLIBCXX_EXPAND_CONSTRUCTORS_DESTRUCTORS__
+
+	template _UCXXEXPORT ostream::sentry::sentry(ostream & os);
+	template _UCXXEXPORT ostream::sentry::~sentry();
+
+#endif //__UCLIBCXX_EXPAND_CONSTRUCTORS_DESTRUCTORS__
+
+	template _UCXXEXPORT ostream & endl(ostream & os);
+	template _UCXXEXPORT ostream & flush(ostream & os);
+	template _UCXXEXPORT ostream & operator<<(ostream & out, char c);
+	template _UCXXEXPORT ostream & operator<<(ostream & out, const char* c);
+	template _UCXXEXPORT ostream & operator<<(ostream & out, unsigned char c);
+	template _UCXXEXPORT ostream & operator<<(ostream & out, const unsigned char* c);
+
+#endif
+
+
+}

misc/uClibc++/libxx/uClib++/queue.cxx

@@ -0,0 +1,27 @@
+/*      Copyright (C) 2004 Garrett A. Kajmowicz
+	This file is part of the uClibc++ Library.
+
+	This library is free software; you can redistribute it and/or
+	modify it under the terms of the GNU Lesser General Public
+	License as published by the Free Software Foundation; either
+	version 2.1 of the License, or (at your option) any later version.
+
+	This library is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+	Lesser General Public License for more details.
+
+	You should have received a copy of the GNU Lesser General Public
+	License along with this library; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+#include <queue>
+
+
+namespace std{
+
+
+
+
+}

misc/uClibc++/libxx/uClib++/set.cxx

@@ -0,0 +1,33 @@
+/*	Copyright (C) 2004 Garrett A. Kajmowicz
+	This file is part of the uClibc++ Library.
+
+	This library is free software; you can redistribute it and/or
+	modify it under the terms of the GNU Lesser General Public
+	License as published by the Free Software Foundation; either
+	version 2.1 of the License, or (at your option) any later version.
+
+	This library is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+	Lesser General Public License for more details.
+
+	You should have received a copy of the GNU Lesser General Public
+	License along with this library; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+*/
+
+#include <set>
+
+namespace std{
+
+
+
+
+
+
+
+
+
+
+}

misc/uClibc++/libxx/uClib++/sstream.cxx

@@ -0,0 +1,59 @@
+/*	Copyright (C) 2004 Garrett A. Kajmowicz
+
+	This file is part of the uClibc++ Library.
+
+	This library is free software; you can redistribute it and/or
+	modify it under the terms of the GNU Lesser General Public
+	License as published by the Free Software Foundation; either
+	version 2.1 of the License, or (at your option) any later version.
+
+	This library is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+	Lesser General Public License for more details.
+
+	You should have received a copy of the GNU Lesser General Public
+	License along with this library; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+#define __UCLIBCXX_COMPILE_SSTREAM__ 1
+
+#include <sstream>
+
+namespace std{
+
+#ifdef __UCLIBCXX_EXPAND_SSTREAM_CHAR__
+
+	typedef char_traits<char> tr_ch;
+	typedef basic_stringbuf<char, tr_ch, allocator<char> > char_stringbuf;
+
+#ifdef __UCLIBCXX_EXPAND_CONSTRUCTORS_DESTRUCTORS__
+
+	template _UCXXEXPORT char_stringbuf::basic_stringbuf(ios_base::openmode which);
+	template _UCXXEXPORT char_stringbuf::~basic_stringbuf();
+
+#endif //__UCLIBCXX_EXPAND_CONSTRUCTORS_DESTRUCTORS__
+
+	template _UCXXEXPORT basic_string<char, char_traits<char>, allocator<char> > char_stringbuf::str() const;
+	template _UCXXEXPORT char_stringbuf::int_type char_stringbuf::pbackfail(char_stringbuf::int_type c);
+	template _UCXXEXPORT char_stringbuf::int_type char_stringbuf::overflow(char_stringbuf::int_type c);
+	template _UCXXEXPORT char_stringbuf::pos_type
+		char_stringbuf::seekoff(char_stringbuf::off_type, ios_base::seekdir, ios_base::openmode);
+	template _UCXXEXPORT char_stringbuf::int_type char_stringbuf::underflow ();
+	template _UCXXEXPORT streamsize char_stringbuf::xsputn(const char* s, streamsize n);
+
+#ifdef __UCLIBCXX_EXPAND_CONSTRUCTORS_DESTRUCTORS__
+
+	template _UCXXEXPORT basic_stringstream<char, tr_ch, allocator<char> >::basic_stringstream(ios_base::openmode which);
+	template _UCXXEXPORT basic_istringstream<char, tr_ch, allocator<char> >::~basic_istringstream();
+	template _UCXXEXPORT basic_ostringstream<char, tr_ch, allocator<char> >::~basic_ostringstream();
+	template _UCXXEXPORT basic_stringstream<char, tr_ch, allocator<char> >::~basic_stringstream();
+
+#endif //__UCLIBCXX_EXPAND_CONSTRUCTORS_DESTRUCTORS__
+
+#endif
+
+}
+
+

misc/uClibc++/libxx/uClib++/stack.cxx

@@ -0,0 +1,27 @@
+/*      Copyright (C) 2004 Garrett A. Kajmowicz
+	This file is part of the uClibc++ Library.
+
+	This library is free software; you can redistribute it and/or
+	modify it under the terms of the GNU Lesser General Public
+	License as published by the Free Software Foundation; either
+	version 2.1 of the License, or (at your option) any later version.
+
+	This library is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+	Lesser General Public License for more details.
+
+	You should have received a copy of the GNU Lesser General Public
+	License along with this library; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+#include <stack>
+
+
+namespace std{
+
+
+
+
+}

misc/uClibc++/libxx/uClib++/stdexcept.cxx

@@ -0,0 +1,63 @@
+/*	Copyright (C) 2004 Garrett A. Kajmowicz
+
+	This file is part of the uClibc++ Library.
+
+	This library is free software; you can redistribute it and/or
+	modify it under the terms of the GNU Lesser General Public
+	License as published by the Free Software Foundation; either
+	version 2.1 of the License, or (at your option) any later version.
+
+	This library is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+	Lesser General Public License for more details.
+
+	You should have received a copy of the GNU Lesser General Public
+	License along with this library; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+#include <exception>
+#include <stdexcept>
+
+#ifdef __UCLIBCXX_EXCEPTION_SUPPORT__
+
+namespace std{
+
+	_UCXXEXPORT logic_error::logic_error() throw() : mstring(){
+
+	}
+
+	_UCXXEXPORT logic_error::logic_error(const string& what_arg) : mstring(what_arg){
+
+	}
+
+	_UCXXEXPORT const char * logic_error::what() const throw(){
+		return mstring.c_str();
+	}
+
+
+	_UCXXEXPORT out_of_range::out_of_range() : logic_error(){
+
+	}
+
+	_UCXXEXPORT out_of_range::out_of_range(const string & what_arg) : logic_error(what_arg) {
+	
+	}
+
+	_UCXXEXPORT runtime_error::runtime_error() : mstring(){
+
+	}
+
+	_UCXXEXPORT runtime_error::runtime_error(const string& what_arg) : mstring(what_arg){
+
+	}
+
+	_UCXXEXPORT const char * runtime_error::what() const throw(){
+		return mstring.c_str();
+	}
+
+}
+
+#endif
+

misc/uClibc++/libxx/uClib++/streambuf.cxx

@@ -0,0 +1,49 @@
+/*	Copyright (C) 2004 Garrett A. Kajmowicz
+
+	This file is part of the uClibc++ Library.
+
+	This library is free software; you can redistribute it and/or
+	modify it under the terms of the GNU Lesser General Public
+	License as published by the Free Software Foundation; either
+	version 2.1 of the License, or (at your option) any later version.
+
+	This library is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+	Lesser General Public License for more details.
+
+	You should have received a copy of the GNU Lesser General Public
+	License along with this library; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+#define __UCLIBCXX_COMPILE_STREAMBUF__ 1
+
+#include <streambuf>
+
+namespace std{
+
+#ifdef __UCLIBCXX_EXPAND_STREAMBUF_CHAR__
+
+#ifdef __UCLIBCXX_EXPAND_CONSTRUCTORS_DESTRUCTORS__
+
+	template _UCXXEXPORT streambuf::basic_streambuf();
+	template _UCXXEXPORT streambuf::~basic_streambuf();
+
+#endif
+
+	template _UCXXEXPORT locale streambuf::pubimbue(const locale &loc);
+	template _UCXXEXPORT streamsize streambuf::in_avail();
+	template _UCXXEXPORT streambuf::int_type streambuf::sbumpc();
+	template _UCXXEXPORT streambuf::int_type streambuf::snextc();
+	template _UCXXEXPORT streambuf::int_type streambuf::sgetc();
+	template _UCXXEXPORT streambuf::int_type streambuf::sputbackc(char_type c);
+	template _UCXXEXPORT streambuf::int_type streambuf::sungetc();
+	template _UCXXEXPORT streambuf::int_type streambuf::sputc(char_type c);
+
+#endif
+
+
+}
+
+

misc/uClibc++/libxx/uClib++/string.cxx

@@ -0,0 +1,112 @@
+/*	Copyright (C) 2004 Garrett A. Kajmowicz
+
+	This file is part of the uClibc++ Library.
+
+	This library is free software; you can redistribute it and/or
+	modify it under the terms of the GNU Lesser General Public
+	License as published by the Free Software Foundation; either
+	version 2.1 of the License, or (at your option) any later version.
+
+	This library is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+	Lesser General Public License for more details.
+
+	You should have received a copy of the GNU Lesser General Public
+	License along with this library; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+#define __UCLIBCXX_COMPILE_STRING__ 1
+
+#include <basic_definitions>
+#include <char_traits>
+#include <string>
+#include <string_iostream>
+#include <string.h>
+#include <ostream>
+
+namespace std{
+
+#ifdef __UCLIBCXX_EXPAND_STRING_CHAR__
+
+#ifdef __UCLIBCXX_EXPAND_CONSTRUCTORS_DESTRUCTORS__
+
+	template _UCXXEXPORT string::basic_string(const allocator<char> &);
+	template _UCXXEXPORT string::basic_string(size_type n, char c, const allocator<char> & );
+	template _UCXXEXPORT string::basic_string(const char* s, const allocator<char>& al);
+	template _UCXXEXPORT string::basic_string(const basic_string& str, size_type pos, size_type n, const allocator<char>& al);
+	template _UCXXEXPORT string::~basic_string();
+
+#endif // __UCLIBCXX_EXPAND_CONSTRUCTORS_DESTRUCTORS__
+
+	template _UCXXEXPORT string & string::append(const char * s, size_type n);
+
+	template _UCXXEXPORT string::size_type string::find(const string & str, size_type pos) const;
+	template _UCXXEXPORT string::size_type string::find(const char* s, size_type pos) const;
+	template _UCXXEXPORT string::size_type string::find (char c, size_type pos) const;
+	template _UCXXEXPORT string::size_type string::rfind(const string & str, size_type pos) const;
+	template _UCXXEXPORT string::size_type string::rfind(char c, size_type pos) const;
+	template _UCXXEXPORT string::size_type string::rfind(const char* s, size_type pos) const;
+
+	template _UCXXEXPORT string::size_type string::find_first_of(const string &, size_type) const;
+	template _UCXXEXPORT string::size_type string::find_first_of(const char *, size_type pos, size_type n) const;
+	template _UCXXEXPORT string::size_type string::find_first_of(const char*, size_type pos) const;
+	template _UCXXEXPORT string::size_type string::find_first_of(char c, size_type pos) const;
+
+	template _UCXXEXPORT string::size_type string::find_last_of (const string & , size_type pos) const;
+	template _UCXXEXPORT string::size_type string::find_last_of (const char* s, size_type pos, size_type n) const;
+	template _UCXXEXPORT string::size_type string::find_last_of (const char* s, size_type pos) const;
+	template _UCXXEXPORT string::size_type string::find_last_of (char c, size_type pos) const;
+
+	template _UCXXEXPORT string::size_type string::find_first_not_of(const string &, size_type) const;
+	template _UCXXEXPORT string::size_type string::find_first_not_of(const char*, size_type, size_type) const;
+	template _UCXXEXPORT string::size_type string::find_first_not_of(const char*, size_type) const;
+	template _UCXXEXPORT string::size_type string::find_first_not_of(char c, size_type) const;
+
+	template _UCXXEXPORT int string::compare(const string & str) const;
+//	template _UCXXEXPORT int string::compare(size_type pos1, size_type n1, const string & str) const;
+	template _UCXXEXPORT int string::compare(
+		size_type pos1, size_type n1, const string & str, size_type pos2, size_type n2) const;
+
+	template _UCXXEXPORT string string::substr(size_type pos, size_type n) const;
+
+	template _UCXXEXPORT string & string::operator=(const string & str);
+	template _UCXXEXPORT string & string::operator=(const char * s);
+
+	template _UCXXEXPORT bool operator==(const string & lhs, const string & rhs);
+	template _UCXXEXPORT bool operator==(const char * lhs, const string & rhs);
+	template _UCXXEXPORT bool operator==(const string & lhs, const char * rhs);
+
+	template _UCXXEXPORT bool operator!=(const string & lhs, const string & rhs);
+	template _UCXXEXPORT bool operator!=(const char * lhs, const string & rhs);
+	template _UCXXEXPORT bool operator!=(const string & lhs, const char * rhs);
+
+	template _UCXXEXPORT string operator+(const string & lhs, const char* rhs);
+	template _UCXXEXPORT string operator+(const char* lhs, const string & rhs);
+	template _UCXXEXPORT string operator+(const string & lhs,	const string & rhs);
+
+	template _UCXXEXPORT bool operator> (const string & lhs, const string & rhs);
+	template _UCXXEXPORT bool operator< (const string & lhs, const string & rhs);
+
+
+//Functions dependent upon OSTREAM
+#ifdef __UCLIBCXX_EXPAND_OSTREAM_CHAR__
+
+template _UCXXEXPORT ostream & operator<<(ostream & os, const string & str);
+
+#endif
+
+
+//Functions dependent upon ISTREAM
+#ifdef __UCLIBCXX_EXPAND_ISTREAM_CHAR__
+
+template _UCXXEXPORT istream & operator>>(istream & is, string & str);
+
+
+#endif
+
+
+#endif
+
+}

misc/uClibc++/libxx/uClib++/support.cxx

@@ -0,0 +1,53 @@
+/*	Copyright (C) 2004 Garrett A. Kajmowicz
+
+	This file is part of the uClibc++ Library.  
+
+	This library is free software; you can redistribute it and/or
+	modify it under the terms of the GNU Lesser General Public
+	License as published by the Free Software Foundation; either
+	version 2.1 of the License, or (at your option) any later version.
+
+	This library is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+	Lesser General Public License for more details.
+
+	You should have received a copy of the GNU Lesser General Public
+	License along with this library; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+#include <support>
+
+extern "C" void *__cxa_allocate_exception(size_t thrown_size){
+	void * retval;
+
+//	The amount of data needed is the size of the object *PLUS*
+//	the size of the header.  The header is of struct __cxa_exception
+//	The address needs to be adjusted because the pointer we return
+//	should not point to the start of the memory, but to the point
+//	where the object being thrown actually starts
+//
+	retval = malloc(thrown_size + sizeof(__cxa_exception));
+
+//	Check to see that we actuall allocated memory
+	if(retval == 0){
+		std::terminate();
+	}
+
+	//Need to do a typecast to char* otherwize we are doing math with
+	//a void* which makes the compiler cranky (Like me)
+	return ((char *)retval + sizeof(__cxa_exception));
+}
+
+extern "C" void __cxa_free_exception(void *thrown_exception){
+
+
+
+}
+
+extern "C" void __cxa_throw (void *thrown_exception, void *info,void (*dest) (void *) ){
+
+
+}
+

misc/uClibc++/libxx/uClib++/typeinfo.cxx

@@ -0,0 +1,34 @@
+/*	Copyright (C) 2004 Garrett A. Kajmowicz
+
+	This file is part of the uClibc++ Library.
+
+	This library is free software; you can redistribute it and/or
+	modify it under the terms of the GNU Lesser General Public
+	License as published by the Free Software Foundation; either
+	version 2.1 of the License, or (at your option) any later version.
+
+	This library is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+	Lesser General Public License for more details.
+
+	You should have received a copy of the GNU Lesser General Public
+	License along with this library; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+#include <typeinfo>
+
+namespace std{
+
+	_UCXXEXPORT bad_cast::~bad_cast() throw(){
+
+	}
+
+	_UCXXEXPORT bad_typeid::~bad_typeid() throw(){
+
+	}
+
+}
+
+

misc/uClibc++/libxx/uClib++/utility.cxx

@@ -0,0 +1,30 @@
+/*	Copyright (C) 2004 Garrett A. Kajmowicz
+	This file is part of the uClibc++ Library.
+
+	This library is free software; you can redistribute it and/or
+	modify it under the terms of the GNU Lesser General Public
+	License as published by the Free Software Foundation; either
+	version 2.1 of the License, or (at your option) any later version.
+
+	This library is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+	Lesser General Public License for more details.
+
+	You should have received a copy of the GNU Lesser General Public
+	License along with this library; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+*/
+
+
+#include <utility>
+
+
+namespace std{
+
+
+
+}
+
+

misc/uClibc++/libxx/uClib++/valarray.cxx

@@ -0,0 +1,29 @@
+/*	Copyright (C) 2004 Garrett A. Kajmowicz
+
+	This file is part of the uClibc++ Library.
+
+	This library is free software; you can redistribute it and/or
+	modify it under the terms of the GNU Lesser General Public
+	License as published by the Free Software Foundation; either
+	version 2.1 of the License, or (at your option) any later version.
+
+	This library is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+	Lesser General Public License for more details.
+
+	You should have received a copy of the GNU Lesser General Public
+	License along with this library; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+#include <valarray>
+
+namespace std{
+
+
+
+
+}
+
+

misc/uClibc++/libxx/uClib++/vector.cxx

@@ -0,0 +1,83 @@
+/*	Copyright (C) 2004 Garrett A. Kajmowicz
+
+	This file is part of the uClibc++ Library.
+
+	This library is free software; you can redistribute it and/or
+	modify it under the terms of the GNU Lesser General Public
+	License as published by the Free Software Foundation; either
+	version 2.1 of the License, or (at your option) any later version.
+
+	This library is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+	Lesser General Public License for more details.
+
+	You should have received a copy of the GNU Lesser General Public
+	License along with this library; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+#define __UCLIBCXX_COMPILE_VECTOR__ 1
+
+
+#include <vector>
+
+namespace std{
+
+
+#ifdef __UCLIBCXX_EXPAND_VECTOR_BASIC__
+
+#ifdef __UCLIBCXX_EXPAND_CONSTRUCTORS_DESTRUCTORS__
+
+	template _UCXXEXPORT vector<char, allocator<char> >::vector(const allocator<char>& al);
+	template _UCXXEXPORT vector<char, allocator<char> >::vector(size_type n, const char & value, const allocator<char> & al);
+
+	template _UCXXEXPORT vector<char, allocator<char> >::~vector();
+	template _UCXXEXPORT vector<unsigned char, allocator<unsigned char> >::~vector();
+
+#endif //__UCLIBCXX_EXPAND_CONSTRUCTORS_DESTRUCTORS__
+
+	template _UCXXEXPORT void vector<char, allocator<char> >::reserve(size_type n);
+	template _UCXXEXPORT void vector<unsigned char, allocator<unsigned char> >::reserve(size_type n);
+	template _UCXXEXPORT void vector<short int, allocator<short int> >::reserve(size_type n);
+	template _UCXXEXPORT void vector<unsigned short int, allocator<unsigned short int> >::reserve(size_type n);
+	template _UCXXEXPORT void vector<int, allocator<int> >::reserve(size_type n);
+	template _UCXXEXPORT void vector<unsigned int, allocator<unsigned int> >::reserve(size_type n);
+	template _UCXXEXPORT void vector<long int, allocator<long int> >::reserve(size_type n);
+	template _UCXXEXPORT void vector<unsigned long int, allocator<unsigned long int> >::reserve(size_type n);
+	template _UCXXEXPORT void vector<float, allocator<float> >::reserve(size_type n);
+	template _UCXXEXPORT void vector<double, allocator<double> >::reserve(size_type n);
+	template _UCXXEXPORT void vector<bool, allocator<bool> >::reserve(size_type n);
+
+	template _UCXXEXPORT void vector<char, allocator<char> >::resize(size_type sz, const char & c);
+	template _UCXXEXPORT void vector<unsigned char, allocator<unsigned char> >::resize(size_type sz, const unsigned char & c);
+	template _UCXXEXPORT void vector<short int, allocator<short int> >::resize(size_type sz, const short & c);
+	template _UCXXEXPORT void vector<unsigned short int, allocator<unsigned short int> >
+		::resize(size_type sz, const unsigned short int & c);
+	template _UCXXEXPORT void vector<int, allocator<int> >::resize(size_type sz, const int & c);
+	template _UCXXEXPORT void vector<unsigned int, allocator<unsigned int> >::resize(size_type sz, const unsigned int & c);
+	template _UCXXEXPORT void vector<long int, allocator<long int> >::resize(size_type sz, const long int & c);
+	template _UCXXEXPORT void vector<unsigned long int, allocator<unsigned long int> >::
+		resize(size_type sz, const unsigned long int & c);
+	template _UCXXEXPORT void vector<float, allocator<float> >::resize(size_type sz, const float & c);
+	template _UCXXEXPORT void vector<double, allocator<double> >::resize(size_type sz, const double & c);
+	template _UCXXEXPORT void vector<bool, allocator<bool> >::resize(size_type sz, const bool & c);
+
+#elif defined __UCLIBCXX_EXPAND_STRING_CHAR__
+
+
+#ifdef __UCLIBCXX_EXPAND_CONSTRUCTORS_DESTRUCTORS__
+	template _UCXXEXPORT vector<char, allocator<char> >::vector(const allocator<char>& al);
+	template _UCXXEXPORT vector<char, allocator<char> >::vector(size_type n, const char & value, const allocator<char> & al);
+	template _UCXXEXPORT vector<char, allocator<char> >::~vector();
+#endif // __UCLIBCXX_EXPAND_CONSTRUCTORS_DESTRUCTORS__
+
+	template _UCXXEXPORT void vector<char, allocator<char> >::reserve(size_type n);
+	template _UCXXEXPORT void vector<char, allocator<char> >::resize(size_type sz, const char & c);
+
+#endif
+
+
+
+
+}

nuttx/libxx/Makefile

@@ -35,20 +35,37 @@
 
 -include $(TOPDIR)/Make.defs
 
-ASRCS		= 
+# Sources
-AOBJS		= $(ASRCS:.S=$(OBJEXT))
-CSRCS		= 
-COBJS		= $(CSRCS:.c=$(OBJEXT))
-CXXSRCS		= libxx_cxapurevirtual.cxx libxx_delete.cxx libxx_deletea.cxx \
-			  libxx_eabi_atexit.cxx libxx_new.cxx libxx_newa.cxx 
-CXXOBJS		= $(CXXSRCS:.cxx=$(OBJEXT))
 
-SRCS		= $(ASRCS) $(CSRCS) $(CXXSRCS)
+ASRCS = 
-OBJS		= $(AOBJS) $(COBJS) $(CXXOBJS)
+CSRCS = 
+CXXSRCS = libxx_cxapurevirtual.cxx libxx_delete.cxx libxx_deletea.cxx
+CXXSRCS += libxx_eabi_atexit.cxx libxx_new.cxx libxx_newa.cxx 
 
-BIN		= liblibxx$(LIBEXT)
+# Paths
 
-all:	$(BIN)
+DEPPATH = --dep-path .
+VPATH = .
+
+# Include the uClibc++ Make.defs file (if it is present).  If is present,
+# the uClibc++/Make.defs file will add its files to the source file list,
+# add its DEPPATH info, and will add the appropriate paths to the VPATH
+# variable
+
+-include/uClibc++/Make.defs
+
+# Object Files
+
+AOBJS = $(ASRCS:.S=$(OBJEXT))
+COBJS = $(CSRCS:.c=$(OBJEXT))
+CXXOBJS = $(CXXSRCS:.cxx=$(OBJEXT))
+
+SRCS = $(ASRCS) $(CSRCS) $(CXXSRCS)
+OBJS = $(AOBJS) $(COBJS) $(CXXOBJS)
+
+BIN = liblibxx$(LIBEXT)
+
+all: $(BIN)
 
 $(AOBJS): %$(OBJEXT): %.S
 	$(call ASSEMBLE, $<, $@)
@@ -65,7 +82,7 @@ $(BIN):	$(OBJS)
 	done ; )
 
 .depend: Makefile $(SRCS)
-	@$(MKDEP) $(CXX) -- $(CXXFLAGS) -- $(SRCS) >Make.dep
+	@$(MKDEP) $(DEPPATH) $(CXX) -- $(CXXFLAGS) -- $(SRCS) >Make.dep
 	@touch $@
 
 depend: .depend