Create an STM32F4Discovery configuration for testing uClibc++

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

37 files changed, 15230 insertions, 12114 deletions

diff --git a/misc/uClibc++/include/uClibc++/algorithm b/misc/uClibc++/include/uClibc++/algorithm
index 5e8f139c0..e13713cfc 100644
--- a/misc/uClibc++/include/uClibc++/algorithm
+++ b/misc/uClibc++/include/uClibc++/algorithm
@@ -1,19 +1,20 @@
-/*	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
-*/
+/*  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 <cstdlib>
 #include <iterator>
@@ -23,1669 +24,2084 @@
 #ifndef __STD_HEADER_ALGORITHM
 #define __STD_HEADER_ALGORITHM 1
 
-//Elliminate any previously defined macro
+//Eliminate any previously defined macro
+
 #undef min
 #undef max
 
 #pragma GCC visibility push(default)
 
-namespace std{
-
-	// subclause _lib.alg.nonmodifying_, non-modifying sequence operations:
-	template<class InputIterator, class Function> _UCXXEXPORT
-		Function for_each(InputIterator first, InputIterator last, Function f)
-	{
-		while(first !=last){
-			f(*first);
-			++first;
-		}
-		return f;
-	}
-
-
-	template<class InputIterator, class T> _UCXXEXPORT
-		InputIterator find(InputIterator first, InputIterator last, const T& value)
-	{
-		while(first !=last && *first != value){
-			++first;
-		}
-		return first;
-	}
-
-	template<class InputIterator, class Predicate> _UCXXEXPORT
-		InputIterator find_if(InputIterator first, InputIterator last, Predicate pred)
-	{
-		while(first !=last && !pred(*first)){
-			++first;
-		}
-		return first;
-	}
-
-	template<class ForwardIterator1, class ForwardIterator2> _UCXXEXPORT ForwardIterator1
-		find_end(ForwardIterator1 first1, ForwardIterator1 last1,
-			ForwardIterator2 first2, ForwardIterator2 last2)
-	{
-		ForwardIterator1 retval = last1;
-		while(first1 !=last1){
-			ForwardIterator1 temp1(first1);
-			ForwardIterator2 temp2(first2);
-			while(temp2!=last2 && temp1!= last1){
-				if(*temp1 != *temp2){
-					break;		//Exit while loop
-				}
-				++temp1;
-				++temp2;
-				if(temp2 == last2){	//Have successfully checked the whole sequence
-					retval = first1;
-				}
-			}
-		}
-		return retval;
-	}
-
-	template<class ForwardIterator1, class ForwardIterator2, class BinaryPredicate> _UCXXEXPORT
-		ForwardIterator1
-		find_end(ForwardIterator1 first1, ForwardIterator1 last1,
-			ForwardIterator2 first2, ForwardIterator2 last2,
-			BinaryPredicate pred)
-	{
-		ForwardIterator1 retval = last1;
-		while(first1 !=last1){
-			ForwardIterator1 temp1(first1);
-			ForwardIterator2 temp2(first2);
-			while(temp2!=last2 && temp1!= last1){
-				if( ! pred(*temp1, *temp2)){
-					break;		//Exit while loop
-				}
-				++temp1;
-				++temp2;
-				if(temp2 == last2){	//Have successfully checked the whole sequence
-					retval = first1;
-				}
-			}
-		}
-		return retval;
-	}
-
-	template<class ForwardIterator1, class ForwardIterator2> _UCXXEXPORT
-		ForwardIterator1
-		find_first_of(ForwardIterator1 first1, ForwardIterator1 last1,
-			ForwardIterator2 first2, ForwardIterator2 last2)
-	{
-		while(first1 != last1){
-			ForwardIterator2 temp2(first2);
-			while(temp2 != last2 ){
-				if(*temp2 == first1){
-					return first1;
-				}
-				++temp2;
-			}
-
-		}
-		return last1;
-	}
-
-	template<class ForwardIterator1, class ForwardIterator2, class BinaryPredicate> _UCXXEXPORT
-		ForwardIterator1
-		find_first_of(ForwardIterator1 first1, ForwardIterator1 last1,
-			ForwardIterator2 first2, ForwardIterator2 last2,
-			BinaryPredicate pred)
-	{
-		while(first1 != last1){
-			ForwardIterator2 temp2(first2);
-			while(temp2 != last2 ){
-				if(*temp2 == first1){
-					return first1;
-				}
-				++temp2;
-			}
-
-		}
-		return last1;
-	}
-
-	template<class ForwardIterator> _UCXXEXPORT ForwardIterator
-		adjacent_find(ForwardIterator first, ForwardIterator last)
-	{
-		ForwardIterator temp;
-		while(first != last){
-			temp = first;
-			++temp;
-			if(*temp == *first){
-				return first;
-			}
-			++first;
-		}
-		return first;
-	}
-
-	template<class ForwardIterator, class BinaryPredicate> _UCXXEXPORT
-		ForwardIterator
-		adjacent_find(ForwardIterator first, ForwardIterator last, BinaryPredicate pred)
-	{
-		ForwardIterator temp;
-		while(first != last){
-			temp = first;
-			++temp;
-			if( pred(*temp, *first)){
-				return first;
-			}
-			++first;
-		}
-		return first;
-	}
-
-	template<class InputIterator, class T> _UCXXEXPORT
-		typename iterator_traits<InputIterator>::difference_type
-		count(InputIterator first, InputIterator last, const T& value)
-	{
-		typename iterator_traits<InputIterator>::difference_type i = 0;
-		while(first!=last){
-			if(*first == value){
-				++i;
-			}
-			++first;
-		}
-		return i;
-	}
-
-	template<class InputIterator, class Predicate> _UCXXEXPORT
-		typename iterator_traits<InputIterator>::difference_type
-		count_if(InputIterator first, InputIterator last, Predicate pred)
-	{
-		typename iterator_traits<InputIterator>::difference_type i = 0;
-		while(first!=last){
-			if( pred(*first) ){
-				++i;
-			}
-			++first;
-		}
-		return i;
-	}
-
-	template<class InputIterator1, class InputIterator2> _UCXXEXPORT
-		pair<InputIterator1, InputIterator2>
-		mismatch(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2)
-	{
-		while(first1 != last1){
-			if(*first1 != *first2){
-				break;
-			}
-			++first1;
-			++first2;
-		}
-
-		pair<InputIterator1, InputIterator2> retval;
-		retval.first = first1;
-		retval.second = first2;
-		return retval;
-	}
-
-	template<class InputIterator1, class InputIterator2, class BinaryPredicate> _UCXXEXPORT
-		pair<InputIterator1, InputIterator2>
-		mismatch(InputIterator1 first1, InputIterator1 last1,
-			InputIterator2 first2, BinaryPredicate pred)
-	{
-		while(first1 != last1){
-			if( !pred(*first1, *first2) ){
-				break;
-			}
-			++first1;
-			++first2;
-		}
-
-		pair<InputIterator1, InputIterator2> retval;
-		retval.first = first1;
-		retval.second = first2;
-		return retval;
-	}
-
-	template<class InputIterator1, class InputIterator2> _UCXXEXPORT
-		bool
-		equal(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2)
-	{
-		while(first1 !=last1){
-			if(*first1 != *first2){
-				return false;
-			}
-			++first1;
-			++first2;
-		}
-		return true;
-	}
-
-	template<class InputIterator1, class InputIterator2, class BinaryPredicate> _UCXXEXPORT
-		bool
-		equal(InputIterator1 first1, InputIterator1 last1,
-			InputIterator2 first2, BinaryPredicate pred)
-	{
-		while(first1 !=last1){
-			if( !pred(*first1, *first2) ){
-				return false;
-			}
-			++first1;
-			++first2;
-		}
-		return true;
-	}
-
-	template<class ForwardIterator1, class ForwardIterator2> _UCXXEXPORT
-		ForwardIterator1 search(ForwardIterator1 first1, ForwardIterator1 last1,
-			ForwardIterator2 first2, ForwardIterator2 last2)
-	{
-		equal_to<typename iterator_traits<ForwardIterator1>::value_type> c;
-		return search(first1, last1, first2, last2, c);
-	}
-
-
-	template<class ForwardIterator1, class ForwardIterator2, class BinaryPredicate> _UCXXEXPORT
-		ForwardIterator1
-		search(ForwardIterator1 first1, ForwardIterator1 last1,
-			ForwardIterator2 first2, ForwardIterator2 last2,
-			BinaryPredicate pred)
-	{
-		while(first1 != last1){
-			ForwardIterator1 temp1(first1);
-			ForwardIterator2 temp2(first2);
-			while(temp2 != last2 && temp1 != last1){
-				if( !pred(*temp2, *temp1) ){
-					break;
-				}
-				++temp1;
-				++temp2;
-				if(temp2 == last2){
-					return first1;
-				}
-			}
-			++first1;
-		}
-		return last1;
-	}
-
-
-	template<class ForwardIterator, class Size, class T> _UCXXEXPORT
-		ForwardIterator
-		search_n(ForwardIterator first, ForwardIterator last, Size count, const T& value)
-	{
-		while( first != last ){
-			if(*first == value){
-				ForwardIterator temp(first);
-				Size i = 1;
-				++first;	//Avoid doing the same comparison over again
-				while(i < count && *temp == value){
-					++first;
-					++i;
-				}
-				if(i == count){
-					return first;
-				}
-			}
-			++first;
-		}
-		return first;
-	}
-
-
-	template<class ForwardIterator, class Size, class T, class BinaryPredicate> _UCXXEXPORT
-		ForwardIterator
-		search_n(ForwardIterator first, ForwardIterator last,
-			Size count, const T& value, BinaryPredicate pred)
-	{
-		while( first != last ){
-			if( pred(*first, value) ){
-				ForwardIterator temp(first);
-				Size i = 1;
-				++first;	//Avoid doing the same comparison over again
-				while(i < count && pred(*temp, value) ){
-					++first;
-					++i;
-				}
-				if(i == count){
-					return first;
-				}
-			}
-			++first;
-		}
-		return first;
-
-	}
-
-	// subclause _lib.alg.modifying.operations_, modifying sequence operations:
-
-	template<class InputIterator, class OutputIterator> _UCXXEXPORT
-		OutputIterator
-		copy(InputIterator first, InputIterator last, OutputIterator result)
-	{
-		while(first != last){
-			*result = *first;
-			++first;
-			++result;
-		}
-		return result;
-	}
-
-	template<class BidirectionalIterator1, class BidirectionalIterator2> _UCXXEXPORT
-		BidirectionalIterator2
-		copy_backward(BidirectionalIterator1 first, BidirectionalIterator1 last,
-			BidirectionalIterator2 result)
-	{
-		while(first !=last ){
-			--result;
-			--last;
-			*result = *last;
-		}
-		return result;
-	}
-
-	template<class T> _UCXXEXPORT void swap(T& a, T& b){
-		T temp(a);
-		a = b;
-		b = temp;
-	}
-
-	template<class ForwardIterator1, class ForwardIterator2> _UCXXEXPORT
-		ForwardIterator2
-		swap_ranges(ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2)
-	{
-		while(first1 != last1){
-			iter_swap(first1, first2);
-			++first1;
-			++first2;
-		}
-		return first2;
-	}
-
-
-	template<class ForwardIterator1, class ForwardIterator2> _UCXXEXPORT
-		void
-		iter_swap(ForwardIterator1 a, ForwardIterator2 b)
-	{
-		typename iterator_traits<ForwardIterator1>::value_type temp(*a);
-		*a = *b;
-		*b = temp;
-	}
-
-
-	template<class InputIterator, class OutputIterator, class UnaryOperation> _UCXXEXPORT
-		OutputIterator
-		transform(InputIterator first, InputIterator last,
-			OutputIterator result, UnaryOperation op)
-	{
-		while(first != last){
-			*result = op(*first);
-			++first;
-			++result;
-		}
-		return result;
-	}
-
-
-	template<class InputIterator1, class InputIterator2, class OutputIterator, class BinaryOperation> _UCXXEXPORT
-		OutputIterator transform(InputIterator1 first1, InputIterator1 last1,
-			InputIterator2 first2, OutputIterator result,
-			BinaryOperation binary_op)
-	{
-		while(first1 != last1){
-			*result = binary_op(*first1, *first2);
-			++first1;
-			++first2;
-			++result;
-		}
-		return result;
-	}
-
-
-	template<class ForwardIterator, class T> _UCXXEXPORT
-		void
-		replace(ForwardIterator first, ForwardIterator last,
-			const T& old_value, const T& new_value)
-	{
-		while(first != last){
-			if(*first == old_value){
-				*first = new_value;
-			}
-			++first;
-		}
-	}
-
-	template<class ForwardIterator, class Predicate, class T> _UCXXEXPORT
-		void
-		replace_if(ForwardIterator first, ForwardIterator last,
-			Predicate pred, const T& new_value)
-	{
-		while(first != last){
-			if( pred(*first) ){
-				*first = new_value;
-			}
-			++first;
-		}
-	}
-
-
-	template<class InputIterator, class OutputIterator, class T> _UCXXEXPORT
-		OutputIterator
-		replace_copy(InputIterator first, InputIterator last,
-			OutputIterator result, const T& old_value, const T& new_value)
-	{
-		while(first != last){
-			if(*first == old_value){
-				*result = new_value;
-			}else{
-				*result = *first;
-			}
-			++first;
-			++result;
-		}
-		return result;
-	}
-
-	template<class Iterator, class OutputIterator, class Predicate, class T> _UCXXEXPORT
-		OutputIterator
-		replace_copy_if(Iterator first, Iterator last,
-			OutputIterator result, Predicate pred, const T& new_value)
-	{
-		while(first != last){
-			if( pred(*first) ){
-				*result = new_value;
-			}else{
-				*result = *first;
-			}
-			++first;
-			++result;
-		}
-		return result;
-	}
-
-	template<class ForwardIterator, class T> _UCXXEXPORT
-		void
-		fill(ForwardIterator first, ForwardIterator last, const T& value)
-	{
-		while(first != last){
-			*first = value;
-			++first;
-		}
-	}
-
-	template<class OutputIterator, class Size, class T> _UCXXEXPORT
-		void
-		fill_n(OutputIterator first, Size n, const T& value)
-	{
-		while(n != 0){
-			*first = value;
-			--n;
-			++first;
-		}
-	}
-
-	template<class ForwardIterator, class Generator> _UCXXEXPORT
-		void
-		generate(ForwardIterator first, ForwardIterator last, Generator gen)
-	{
-		while(first != last){
-			*first = gen();
-			++first;
-		}
-	}
-
-	template<class OutputIterator, class Size, class Generator> _UCXXEXPORT
-		void
-		generate_n(OutputIterator first, Size n, Generator gen)
-	{
-		while(n !=0){
-			*first = gen();
-			--n;
-			++first;
-		}
-	}
-
-	template<class ForwardIterator, class T> _UCXXEXPORT
-		ForwardIterator
-		remove(ForwardIterator first, ForwardIterator last, const T& value)
-	{
-		ForwardIterator temp(first);
-		while(temp !=last){
-			if(*temp == value){
-
-			}else{
-				*first = *temp;
-				++first;
-			}
-			++temp;
-		}
-		return first;
-	}
-
-	template<class ForwardIterator, class Predicate> _UCXXEXPORT
-		ForwardIterator
-		remove_if(ForwardIterator first, ForwardIterator last, Predicate pred)
-	{
-		ForwardIterator temp(first);
-		while(temp !=last){
-			if( pred(*temp) ){
-
-			}else{
-				*first = *temp;
-				++first;
-			}
-			++temp;
-		}
-		return first;
-	}
-
-
-	template<class InputIterator, class OutputIterator, class T> _UCXXEXPORT
-		OutputIterator
-		remove_copy(InputIterator first, InputIterator last,
-			OutputIterator result, const T& value)
-	{
-		while(first !=last){
-			if(*first != value){
-				*result = *first;
-				++result;
-			}
-			++first;
-		}
-		return result;
-	}
-
-	template<class InputIterator, class OutputIterator, class Predicate> _UCXXEXPORT
-		OutputIterator
-		remove_copy_if(InputIterator first, InputIterator last,
-			OutputIterator result, Predicate pred)
-	{
-		while(first !=last){
-			if( !pred(*first) ){
-				*result = *first;
-				++result;
-			}
-			++first;
-		}
-		return result;
-	}
-
-	template<class ForwardIterator> _UCXXEXPORT
-		ForwardIterator
-		unique(ForwardIterator first, ForwardIterator last)
-	{
-		ForwardIterator new_val(first);
-		ForwardIterator old_val(first);
-
-		while(new_val !=last){
-			if(*new_val == *old_val && new_val != old_val){
-
-			}else{
-				*first = *new_val;
-				old_val = new_val;
-				++first;
-			}
-			++new_val;
-		}
-		return first;
-	}
-
-	template<class ForwardIterator, class BinaryPredicate> _UCXXEXPORT
-		ForwardIterator
-		unique(ForwardIterator first, ForwardIterator last, BinaryPredicate pred)
-	{
-		ForwardIterator new_val(first);
-		ForwardIterator old_val(first);
-
-		while(new_val !=last){
-			if( pred(*new_val, *old_val) && new_val != old_val){
-
-			}else{
-				*first = *new_val;
-				old_val = new_val;
-				++first;
-			}
-			++new_val;
-		}
-		return first;
-	}
-
-	template<class InputIterator, class OutputIterator> _UCXXEXPORT
-		OutputIterator
-		unique_copy(InputIterator first, InputIterator last, OutputIterator result)
-	{
-		InputIterator temp(first);
-		while(first !=last ){
-			if(*first == *temp && first != temp){
-
-			}else{
-				*result = *first;
-				temp = first;
-				++result;
-			}
-			++first;
-		}
-		return result;
-	}
-
-	template<class InputIterator, class OutputIterator, class BinaryPredicate> _UCXXEXPORT
-		OutputIterator
-		unique_copy(InputIterator first, InputIterator last,
-			OutputIterator result, BinaryPredicate pred)
-	{
-		InputIterator temp(first);
-		while(first !=last ){
-			if( pred(*first, *temp) && first != temp){
-
-			}else{
-				*result = *first;
-				temp = first;
-				++result;
-			}
-			++first;
-		}
-		return result;
-	}
-
-	template<class BidirectionalIterator> _UCXXEXPORT
-		void
-		reverse(BidirectionalIterator first, BidirectionalIterator last)
-	{
-		--last;		//Don't work with one past the end element
-		while(first < last){
-			iter_swap(first, last);
-			++first;
-			--last;
-		}
-	}
-
-	template<class BidirectionalIterator, class OutputIterator> _UCXXEXPORT
-		OutputIterator
-		reverse_copy(BidirectionalIterator first, BidirectionalIterator last,
-		OutputIterator result)
-	{
-		while(last > first){
-			--last;
-			*result = *last;
-			++result;
-		}
-		return result;
-	}
-
-	template<class ForwardIterator> _UCXXEXPORT
-		void
-		rotate(ForwardIterator first, ForwardIterator middle, ForwardIterator last)
-	{
-		if ((first == middle) || (last  == middle)){
-			return;
-		}
-
-		ForwardIterator first2 = middle;
-
-		do {
-			swap(*first, *first2);
-			first++;
-			first2++;
-			if(first == middle){
-				middle = first2;
-			}
-		} while(first2 != last);
-
-		first2 = middle;
-
-		while (first2 != last) {
-			swap(*first, *first2);
-			first++;
-			first2++;
-			if (first == middle){
-				middle = first2;
-			}else if (first2 == last){
-				first2 = middle;
-			}
-		}
-	}
-
-	template<class ForwardIterator, class OutputIterator> _UCXXEXPORT
-		OutputIterator
-		rotate_copy(ForwardIterator first, ForwardIterator middle,
-			ForwardIterator last, OutputIterator result)
-	{
-		ForwardIterator temp(middle);
-		while(temp !=last){
-			*result = *temp;
-			++temp;
-			++result;
-		}
-		while(first != middle){
-			*result = *first;
-			++first;
-			++result;
-		}
-		return result;
-	}
-
-
-	template<class RandomAccessIterator> _UCXXEXPORT
-		void
-		random_shuffle(RandomAccessIterator first, RandomAccessIterator last)
-	{
-		--last;
-		while(first != last){
-			iter_swap(first, (first + (rand() % (last - first) ) ) );
-			++first;
-		}
-	}
-
-	template<class RandomAccessIterator, class RandomNumberGenerator> _UCXXEXPORT
-		void
-		random_shuffle(RandomAccessIterator first, RandomAccessIterator last,
-		RandomNumberGenerator& rand)
-	{
-		--last;
-		while(first != last){
-			iter_swap(first, (first + (rand(last - first) ) ) );
-			++first;
-		}
-	}
-
-	// _lib.alg.partitions_, partitions:
-	template<class BidirectionalIterator, class Predicate> _UCXXEXPORT BidirectionalIterator
-		partition(BidirectionalIterator first, BidirectionalIterator last, Predicate pred)
-	{
-		return stable_partition(first, last, pred);
-	}
-
-	template<class BidirectionalIterator, class Predicate> _UCXXEXPORT BidirectionalIterator
-		stable_partition(BidirectionalIterator first, BidirectionalIterator last, Predicate pred)
-	{
-		//first now points to the first non-desired element
-		while( first != last && pred(*first) ){
-			++first;
-		}
-
-		BidirectionalIterator tempb;
-		BidirectionalIterator tempe = first;
-
-		while( tempe != last ){
-			//Find the next desired element
-			while( !pred(*tempe) ){
-				++tempe;
-
-				//See if we should exit
-				if(tempe == last){
-					return first;
-				}
-			}
-
-			//Rotate the element back to the begining
-			tempb = tempe;
-			while(tempb != first){
-				iter_swap(tempb, tempb-1 );
-				--tempb;
-			}
-			//First now has a desired element
-			++first;
-		}
-
-		return first;
-	}
-
-	template<class RandomAccessIterator> _UCXXEXPORT
-		void sort(RandomAccessIterator first, RandomAccessIterator last)
-	{
-		less<typename iterator_traits<RandomAccessIterator>::value_type> c;
-		sort(first, last, c );
-	}
-
-	template<class RandomAccessIterator, class Compare> _UCXXEXPORT
-		void sort(RandomAccessIterator first, RandomAccessIterator last, Compare comp)
-	{
-		stable_sort(first, last, comp);
-	}
-
-	template<class RandomAccessIterator> _UCXXEXPORT
-		void stable_sort(RandomAccessIterator first, RandomAccessIterator last)
-	{
-		less<typename iterator_traits<RandomAccessIterator>::value_type> c;
-		stable_sort(first, last, c);
-	}
-
-	template<class RandomAccessIterator, class Compare> _UCXXEXPORT
-		void stable_sort(RandomAccessIterator first, RandomAccessIterator last, Compare comp)
-	{
-		//FIXME - bubble sort
-		RandomAccessIterator temp;
-		--last;
-		while(last - first > 0){
-			temp = last;
-			while(temp != first){
-				if( comp( *temp, *(temp-1) ) ){
-					iter_swap( temp-1, temp);
-				}
-				--temp;
-			}
-			++first;
-		}
-	}
-
-	template<class RandomAccessIterator> _UCXXEXPORT
-		void partial_sort(RandomAccessIterator first, RandomAccessIterator middle, RandomAccessIterator last)
-	{
-		less<typename iterator_traits<RandomAccessIterator>::value_type> c;
-		partial_sort(first, middle, last, c);
-	}
-	template<class RandomAccessIterator, class Compare> _UCXXEXPORT
-		void partial_sort(RandomAccessIterator first, RandomAccessIterator middle,
-			RandomAccessIterator last, Compare comp)
-	{
-		//Fixme - partial bubble sort
-		RandomAccessIterator temp;
-		--last;
-		while(first < middle){
-			temp = last;
-			while(temp != first){
-				if( comp(*temp, *(temp -1 ) ) ) {
-					iter_swap( temp-1, temp);
-				}
-				--temp;
-			}
-			++first;
-		}
-	}
-	template<class InputIterator, class RandomAccessIterator> _UCXXEXPORT
-		RandomAccessIterator
-		partial_sort_copy(InputIterator first, InputIterator last,
-			RandomAccessIterator result_first, RandomAccessIterator result_last)
-	{
-		less<typename iterator_traits<RandomAccessIterator>::value_type> c;
-		return partial_sort_copy(first, last, result_first, result_last, c);
-	}
-	template<class InputIterator, class RandomAccessIterator, class Compare> _UCXXEXPORT
-		RandomAccessIterator
-		partial_sort_copy(InputIterator first, InputIterator last,
-			RandomAccessIterator result_first, RandomAccessIterator result_last, Compare comp)
-	{
-		size_t output_size = last-first;
-		size_t temp_size = result_last - result_first;
-		if(temp_size < output_size){
-			output_size = temp_size;
-		}
-
-		RandomAccessIterator middle = result_first + output_size;
-		RandomAccessIterator temp = result_first;
-
-		while(temp != middle){
-			*temp = *first;
-			++temp;
-			++first;
-		}
-		sort(result_first, middle, comp);
-
-		while( first != last){
-			if( comp( *first, *(middle-1) ) ){
-				*(middle-1) = *first;
-				sort(result_first, middle, comp);
-			}
-			++first;
-		}
-
-		return middle;
-	}
-	template<class RandomAccessIterator> _UCXXEXPORT
-		void nth_element(RandomAccessIterator first, RandomAccessIterator nth, RandomAccessIterator last)
-	{
-		less<typename iterator_traits<RandomAccessIterator>::value_type> c;
-		nth_element(first, nth, last, c);
-	}
-	template<class RandomAccessIterator, class Compare> _UCXXEXPORT
-		void nth_element(RandomAccessIterator first, RandomAccessIterator nth,
-			RandomAccessIterator last, Compare comp)
-	{
-		partial_sort(first, nth, last, comp);
-	}
-
-	template<class ForwardIterator, class T> _UCXXEXPORT
-		ForwardIterator lower_bound(ForwardIterator first, ForwardIterator last,
-			const T& value)
-	{
-		less<typename iterator_traits<ForwardIterator>::value_type> c;
-		return lower_bound(first, last, value, c);
-	}
-
-	template<class ForwardIterator, class T, class Compare> _UCXXEXPORT
-		ForwardIterator lower_bound(ForwardIterator first, ForwardIterator last,
-			const T& value, Compare comp)
-	{
-		if(first == last){
-			return last;
-		}
-		//If below or equal to the first element
-		if( comp(*first, value) == false){
-			return first;
-		}
-		ForwardIterator middle;
-
-		//If greater than the top element
-		middle = first;
-		advance(middle, distance(first, last) - 1);
-		if( comp(*middle, value) ){
-			return last;
-		}
-
-		//Now begin the actual search for the begining
-		while( distance(first, last) > 1 ){
-			//Find middle
-			middle = first;
-			advance(middle, (distance(first, last)/2) );
-			if( !comp(*middle, value) ){
-				last = middle;
-			}else{
-				first = middle;
-			}
-		}
-
-		if( !comp(*first, value) ){
-			return first;
-		}
-		return last;
-	}
-
-	template<class ForwardIterator, class T> _UCXXEXPORT
-		ForwardIterator upper_bound(ForwardIterator first, ForwardIterator last,
-			const T& value)
-	{
-		less<typename iterator_traits<ForwardIterator>::value_type> c;
-		return upper_bound(first, last, value, c);
-	}
-
-
-	template<class ForwardIterator, class T, class Compare> _UCXXEXPORT
-		ForwardIterator upper_bound(ForwardIterator first, ForwardIterator last,
-			const T& value, Compare comp)
-	{
-		if(first == last){
-			return last;
-		}
-		//If below the first element
-		if( comp(value, *first) == true){
-			return first;
-		}
-
-		ForwardIterator middle;
-
-		//If greater than the top element
-		middle = first;
-		advance(middle, distance(first, last) - 1);
-		if( comp(*middle, value) ){
-			return last;
-		}
-
-		//Now begin the actual search for the end
-		while( distance(first, last) > 1 ){
-			//Find middle
-			middle = first;
-			advance(middle, (distance(first, last)/2) );
-			if( comp(value, *middle) ){
-				last = middle;
-			}else{
-				first = middle;
-			}
-		}
-
-		if( comp(value, *first) ){
-			return first;
-		}
-		return last;
-	}
-
-
-	template<class ForwardIterator, class T> _UCXXEXPORT
-		pair<ForwardIterator, ForwardIterator>
-		equal_range(ForwardIterator first, ForwardIterator last, const T& value)
-	{
-		less<typename iterator_traits<ForwardIterator>::value_type> c;
-		return equal_range(first, last, value, c);
-	}
-
-	template<class ForwardIterator, class T, class Compare> _UCXXEXPORT
-		pair<ForwardIterator, ForwardIterator>
-		equal_range(ForwardIterator first, ForwardIterator last, const T& value, Compare comp)
-	{
-		pair<ForwardIterator, ForwardIterator> retval;
-		retval.first = lower_bound(first, last, value, comp);
-		//Reuse retval.first in order to (possibly) save a few comparisons
-		retval.second = upper_bound(retval.first, last, value, comp);
-		return retval;
-
-	}
-
-	template<class ForwardIterator, class T> _UCXXEXPORT
-		bool binary_search(ForwardIterator first, ForwardIterator last,
-			const T& value)
-	{
-		less<typename iterator_traits<ForwardIterator>::value_type> c;
-		return binary_search(first, last, value, c);
-	}
-
-	template<class ForwardIterator, class T, class Compare> _UCXXEXPORT
-		bool binary_search(ForwardIterator first, ForwardIterator last,
-			const T& value, Compare comp)
-	{
-		if( distance(first, last) == 0){
-			return false;
-		}
-
-		ForwardIterator middle;
-
-		while( distance(first, last) > 1 ){
-			//Set middle between first and last
-			middle = first;
-			advance(middle, distance(first, last)/2 );
-
-			if( comp(*middle, value ) == true){
-				first = middle;
-			}else{
-				last = middle;
-			}
-		}
-
-		if( !comp(*first, value) && !comp(value, *first) ){
-			return true;
-		}
-		if( !comp(*last, value) && !comp(value, *last) ){
-			return true;
-		}
-
-		return false;
-	}
-
-	// _lib.alg.merge_, merge:
-	template<class InputIterator1, class InputIterator2, class OutputIterator> _UCXXEXPORT
-		OutputIterator
-		merge(InputIterator1 first1, InputIterator1 last1,
-			InputIterator2 first2, InputIterator2 last2, OutputIterator result)
-	{
-		less<typename iterator_traits<InputIterator1>::value_type> c;
-		return merge(first1, last1, first2, last2, result, c);
-	}
-	template<class InputIterator1, class InputIterator2, class OutputIterator, class Compare> _UCXXEXPORT
-		OutputIterator
-		merge(InputIterator1 first1, InputIterator1 last1,
-			InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp)
-	{
-		while( first1 != last1 && first2 != last2){
-			//If in this order so first1 elements which are equal come first
-			if( comp(*first2, *first1) ){
-				*result = *first2;
-				++first2;
-			}else{
-				*result = *first1;
-				++first1;
-			}
-			++result;
-		}
-		//Clean up remaining elements
-		while(first1 != last1){
-			*result = *first1;
-			++first1;
-			++result;
-		}
-		while(first2 != last2){
-			*result = *first2;
-			++first2;
-			++result;
-		}
-		return result;
-	}
-	template<class BidirectionalIterator> _UCXXEXPORT
-		void inplace_merge(BidirectionalIterator first,
-			BidirectionalIterator middle, BidirectionalIterator last)
-	{
-		less<typename iterator_traits<BidirectionalIterator>::value_type> c;
-		inplace_merge(first, middle, last, c);
-	}
-	template<class BidirectionalIterator, class Compare> _UCXXEXPORT
-		void inplace_merge(BidirectionalIterator first,
-			BidirectionalIterator middle, BidirectionalIterator last, Compare comp)
-	{
-		//FIXME - using a bubble exchange method
-		while(first != middle && middle !=last){
-			if( comp(*middle, *first) ){
-				BidirectionalIterator temp(middle);
-				while( temp != first){
-					iter_swap(temp, temp-1);
-					--temp;
-				}
-				++middle;
-			}
-			++first;
-		}
-	}
-
-	// _lib.alg.set.operations_, set operations:
-	template<class InputIterator1, class InputIterator2> _UCXXEXPORT
-		bool includes(InputIterator1 first1, InputIterator1 last1,
-			InputIterator2 first2, InputIterator2 last2)
-	{
-		less<typename iterator_traits<InputIterator1>::value_type> c;
-		return includes(first1, last1, first2, last2, c );
-	}
-
-	template<class InputIterator1, class InputIterator2, class Compare> _UCXXEXPORT
-		bool includes(InputIterator1 first1, InputIterator1 last1,
-			InputIterator2 first2, InputIterator2 last2, Compare comp)
-	{
-		while(first2 != last2){
-			//Advance the large set until no longer smaller than the element we are looking for
-			while( comp(*first1, *first2) ){
-				++first1;
-				//If we are at the end of the list, we don't have the desired element
-				if(first1 == last1){
-					return false;
-				}
-			}
-			//If we are past the element we want, it isn't here
-			if( comp(*first2, *first1) ){
-				return false;
-			}
-			++first2;	//Move to next element
-		}
-		return true;
-	}
-
-	template<class InputIterator1, class InputIterator2, class OutputIterator> _UCXXEXPORT
-		OutputIterator set_union(InputIterator1 first1, InputIterator1 last1,
-			InputIterator2 first2, InputIterator2 last2, OutputIterator result)
-	{
-		less<typename iterator_traits<InputIterator1>::value_type> c;
-		return set_union(first1, last1, first2, last2, result, c);
-	}
-
-	template<class InputIterator1, class InputIterator2, class OutputIterator, class Compare> _UCXXEXPORT
-		OutputIterator set_union(InputIterator1 first1, InputIterator1 last1,
-			InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp)
-	{
-		while( first1 != last1 && first2 != last2){
-			if( comp(*first2, *first1) ){
-				*result = *first2;
-
-				//Elliminate duplicates
-				InputIterator2 temp = first2;
-				while( first1 != last1 && !comp( *temp, *first1) ){
-					++first1;
-				}
-				while( first2 != last2 && !comp( *temp, *first2) ){
-					++first2;
-				}
-			}else{
-				*result = *first1;
-					//Elliminate duplicates
-				InputIterator1 temp = first1;
-				while( first1 != last1 && !comp( *temp, *first1) ){
-					++first1;
-				}
-				while( first2 != last2 && !comp( *temp, *first2) ){
-					++first2;
-				}
-			}
-			++result;
-		}
-
-		//Clean up remaining elements
-		while(first1 != last1){
-			*result = *first1;
-			++result;
-			InputIterator1 temp = first1;
-			while( first1 != last1 && !comp( *temp, *first1) ){
-				++first1;
-			}
-		}
-
-		while(first2 != last2){
-			*result = *first2;
-			++result;
-			InputIterator2 temp = first2;
-			while( first2 != last2 && !comp( *temp, *first2) ){
-				++first2;
-			}
-		}
-		return result;
-	}
-
-	template<class InputIterator1, class InputIterator2, class OutputIterator> _UCXXEXPORT
-		OutputIterator set_intersection(InputIterator1 first1, InputIterator1 last1,
-			InputIterator2 first2, InputIterator2 last2, OutputIterator result)
-	{
-		less<typename iterator_traits<InputIterator1>::value_type> c;
-		return set_intersection(first1, last1, first2, last2, result, c);
-	}
-	template<class InputIterator1, class InputIterator2, class OutputIterator, class Compare> _UCXXEXPORT
-		OutputIterator set_intersection(InputIterator1 first1, InputIterator1 last1,
-			InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp)
-	{
-		while( first1 != last1 && first2 != last2){
-			if( comp(*first2, *first1) ){
-				++first2;
-			}else if( comp(*first1, *first2) ) {
-				++first1;
-			}else{
-				*result = *first1;
-				++result;
-				InputIterator1 temp = first1;
-				while( first1 != last1 && !comp( *temp, *first1) ){
-					++first1;
-				}
-				++first2;
-			}
-		}
-		return result;
-	}
-	template<class InputIterator1, class InputIterator2, class OutputIterator> _UCXXEXPORT
-		OutputIterator set_difference(InputIterator1 first1, InputIterator1 last1,
-			InputIterator2 first2, InputIterator2 last2, OutputIterator result)
-	{
-		less<typename iterator_traits<InputIterator1>::value_type> c;
-		return set_difference(first1, last1, first2, last2, result, c);
-	}
-	template<class InputIterator1, class InputIterator2, class OutputIterator, class Compare> _UCXXEXPORT
-		OutputIterator set_difference(InputIterator1 first1, InputIterator1 last1,
-			InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp)
-	{
-		while( first1 != last1 && first2 != last2){
-			if( comp(*first1, *first2) ){
-				*result = *first1;
-				++result;
-
-				//Elliminate duplicates
-				InputIterator1 temp = first1;
-				while( first1 != last1 && !comp( *temp, *first1) ){
-					++first1;
-				}
-			}else if( comp(*first2, *first1) ){
-
-				//Elliminate duplicates
-				InputIterator2 temp = first2;
-				while( first2 != last2 && !comp( *temp, *first2) ){
-					++first2;
-				}
-
-			}else{	//They are identical - skip
-				//Elliminate duplicates
-				InputIterator1 temp = first1;
-				while( first1 != last1 && !comp( *temp, *first1) ){
-					++first1;
-				}
-				while( first2 != last2 && !comp( *temp, *first2) ){
-					++first2;
-				}
-			}
-		}
-
-		//Clean up remaining elements
-		while(first1 != last1){
-			*result = *first1;
-			++result;
-			InputIterator1 temp = first1;
-			while( first1 != last1 && !comp( *temp, *first1) ){
-				++first1;
-			}
-		}
-
-		return result;
-	}
-	template<class InputIterator1, class InputIterator2, class OutputIterator> _UCXXEXPORT
-		OutputIterator set_symmetric_difference(InputIterator1 first1, InputIterator1 last1,
-			InputIterator2 first2, InputIterator2 last2, OutputIterator result)
-	{
-		less<typename iterator_traits<InputIterator1>::value_type> c;
-		return set_symmetric_difference(first1, last1, first2, last2, result, c);
-	}
-	template<class InputIterator1, class InputIterator2, class OutputIterator, class Compare> _UCXXEXPORT
-		OutputIterator set_symmetric_difference(InputIterator1 first1, InputIterator1 last1,
-			InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp)
-	{
-		while( first1 != last1 && first2 != last2){
-			if( comp(*first1, *first2) ){
-				*result = *first1;
-				++result;
-
-				//Elliminate duplicates
-				InputIterator1 temp = first1;
-				while( first1 != last1 && !comp( *temp, *first1) ){
-					++first1;
-				}
-			}else if( comp(*first2, *first1) ){
-				*result = *first2;
-				++result;
-
-				//Elliminate duplicates
-				InputIterator2 temp = first2;
-				while( first2 != last2 && !comp( *temp, *first2) ){
-					++first2;
-				}
-
-			}else{	//They are identical - skip
-				//Elliminate duplicates
-				InputIterator1 temp = first1;
-				while( first1 != last1 && !comp( *temp, *first1) ){
-					++first1;
-				}
-				while( first2 != last2 && !comp( *temp, *first2) ){
-					++first2;
-				}
-			}
-		}
-
-		//Clean up remaining elements
-		while(first1 != last1){
-			*result = *first1;
-			++result;
-			InputIterator1 temp = first1;
-			while( first1 != last1 && !comp( *temp, *first1) ){
-				++first1;
-			}
-		}
-
-		while(first2 != last2){
-			*result = *first2;
-			++result;
-			InputIterator2 temp = first2;
-			while( first2 != last2 && !comp( *temp, *first2) ){
-				++first2;
-			}
-		}
-
-		return result;
-	}
-
-	// _lib.alg.heap.operations_, heap operations:
-
-	template<class RandomAccessIterator> _UCXXEXPORT
-		void push_heap(RandomAccessIterator first, RandomAccessIterator last)
-	{
-		less<typename iterator_traits<RandomAccessIterator>::value_type> c;
-		push_heap(first, last, c);
-	}
-
-	template<class RandomAccessIterator, class Compare> _UCXXEXPORT
-		void push_heap(RandomAccessIterator first, RandomAccessIterator last, Compare comp)
-	{
-		// *(last - 1) is the last element
-		RandomAccessIterator begin, middle, end;
-		begin = first;
-		end = last - 2;
-		if(last - first < 2){		//Empty heap
-			return;
-		}
-		if ( comp(*(last-1), *end) ){	//Belongs past the end - already in place
-			return;
-		}
-		while(end - begin > 1){
-			middle = begin + ((end - begin)/2);
-			if( comp(*middle, *(last-1) ) ){
-				end = middle;
-			}else{
-				begin = middle;
-			}
-		}
-
-		if( comp(*begin, *(last-1)) ){
-			middle = begin;
-		}else{
-			middle = end;
-		}
-
-		//Now all we do is swap the elements up to the begining
-		--last;
-
-		while(last > middle){
-			iter_swap(last, last-1);
-			--last;
-		}
-	}
-
-	template<class RandomAccessIterator> _UCXXEXPORT
-		void pop_heap(RandomAccessIterator first, RandomAccessIterator last)
-	{
-		less<typename iterator_traits<RandomAccessIterator>::value_type> c;
-		pop_heap(first, last, c);
-	}
-	template<class RandomAccessIterator, class Compare> _UCXXEXPORT
-		void pop_heap(RandomAccessIterator first, RandomAccessIterator last, Compare)
-	{
-		--last;
-		while(first < last){
-			iter_swap( first, first+1);
-			++first;
-		}
-	}
-
-	template<class RandomAccessIterator> _UCXXEXPORT
-		void make_heap(RandomAccessIterator first, RandomAccessIterator last)
-	{
-		less<typename iterator_traits<RandomAccessIterator>::value_type> c;
-		make_heap(first, last, c);
-	}
-	template<class RandomAccessIterator, class Compare> _UCXXEXPORT
-		void make_heap(RandomAccessIterator first, RandomAccessIterator last, Compare comp)
-	{
-		sort( reverse_iterator<RandomAccessIterator>(last), reverse_iterator<RandomAccessIterator>(first), comp);
-	}
-	template<class RandomAccessIterator> _UCXXEXPORT
-		void sort_heap(RandomAccessIterator first, RandomAccessIterator last)
-	{
-		less<typename iterator_traits<RandomAccessIterator>::value_type> c;
-		sort_heap(first, last, c);
-	}
-	template<class RandomAccessIterator, class Compare> _UCXXEXPORT
-		void sort_heap(RandomAccessIterator first, RandomAccessIterator last, Compare comp)
-	{
-		sort( first, last, comp);
-	}
-
-
-	// _lib.alg.min.max_, minimum and maximum:
-	template<class T> _UCXXEXPORT
-		const T& min(const T& a, const T& b)
-	{
-		if(b < a){
-			return b;
-		}
-		return a;
-	}
-
-	template<class T, class Compare> _UCXXEXPORT
-		const T& min(const T& a, const T& b, Compare comp)
-	{
-		if( comp(b, a) == true){
-			return b;
-		}
-		return a;
-	}
-
-	template<class T> _UCXXEXPORT
-		const T& max(const T& a, const T& b)
-	{
-		if( a < b){
-			return b;
-		}
-		return a;
-	}
-
-	template<class T, class Compare> _UCXXEXPORT
-		const T& max(const T& a, const T& b, Compare comp)
-	{
-		if( comp(a, b) ){
-			return b;
-		}
-		return a;
-	}
-
-	template<class ForwardIterator> _UCXXEXPORT
-		ForwardIterator min_element(ForwardIterator first, ForwardIterator last)
-	{
-		less<typename iterator_traits<ForwardIterator>::value_type> c;
-		return min_element(first, last, c);
-	}
-
-	template<class ForwardIterator, class Compare> _UCXXEXPORT
-		ForwardIterator min_element(ForwardIterator first, ForwardIterator last, Compare comp)
-	{
-		ForwardIterator retval = first;
-		++first;
-		while(first != last){
-			if( comp( *first, *retval) ){
-				retval = first;
-			}
-			++first;
-		}
-		return retval;
-	}
-
-	template<class ForwardIterator> _UCXXEXPORT
-		ForwardIterator max_element(ForwardIterator first, ForwardIterator last)
-	{
-		less<typename iterator_traits<ForwardIterator>::value_type> c;
-		return max_element(first, last, c);
-	}
-
-	template<class ForwardIterator, class Compare> _UCXXEXPORT
-		ForwardIterator max_element(ForwardIterator first, ForwardIterator last, Compare comp)
-	{
-		ForwardIterator retval = first;
-		++first;
-		while(first != last){
-			if( comp( *retval, *first ) ){
-				retval = first;
-			}
-			++first;
-		}
-		return retval;
-	}
-
-	template<class InputIterator1, class InputIterator2> _UCXXEXPORT
-		bool lexicographical_compare(InputIterator1 first1, InputIterator1 last1,
-			InputIterator2 first2, InputIterator2 last2)
-	{
-		less<typename iterator_traits<InputIterator1>::value_type> c;
-		return lexicographical_compare(first1, last1, first2, last2, c);
-	}
-
-	template<class InputIterator1, class InputIterator2, class Compare> _UCXXEXPORT
-		bool lexicographical_compare(InputIterator1 first1, InputIterator1 last1,
-			InputIterator2 first2, InputIterator2 last2, Compare comp)
-	{
-		while(first1 != last1 && first2 != last2){
-			if( comp(*first1, *first2) ){
-				return true;
-			}
-			if( comp(*first2, *first1) ){
-				return false;
-			}
-			++first1;
-			++first2;
-		}
-		return first1==last1 && first2 != last2;
-	}
-
-	// _lib.alg.permutation.generators_, permutations
-	template<class BidirectionalIterator> _UCXXEXPORT
-		bool next_permutation(BidirectionalIterator first, BidirectionalIterator last)
-	{
-		less<typename iterator_traits<BidirectionalIterator>::value_type> c;
-		return next_permutation(first, last, c);
-	}
-
-	template<class BidirectionalIterator, class Compare> _UCXXEXPORT
-		bool next_permutation(BidirectionalIterator first, BidirectionalIterator last, Compare comp)
-	{
-		if(first == last){
-			return false;	// No data
-		}
-		BidirectionalIterator i = last;
-		--i;
-		if(i == first){
-			return false;	//Only one element
-		}
-		BidirectionalIterator ii = i;
-		--ii;
-		//If the last two items are in order, swap them and call it done
-		if( comp(*ii, *i) ){
-			iter_swap(ii, i);
-			return true;
-		}
-
-
-		//This part of the algorithm copied from G++ header files ver. 3.4.2
-		i = last;
-		--i;
-		for(;;){
-			ii = i;
-			--i;
-			if ( comp(*i, *ii) ){
-				BidirectionalIterator j = last;
-				--j;
-				while ( !comp(*i, *j)){
-					--j;
-				}
-				iter_swap(i, j);
-				reverse(ii, last);
-				return true;
-			}
-			if (i == first){
-				reverse(first, last);
-				return false;
-			}
-		}
-
-
-	}
-
-	template<class BidirectionalIterator> _UCXXEXPORT
-		bool prev_permutation(BidirectionalIterator first, BidirectionalIterator last)
-	{
-		less<typename iterator_traits<BidirectionalIterator>::value_type> c;
-		return prev_permutation(first, last, c);
-	}
-
-	template<class BidirectionalIterator, class Compare> _UCXXEXPORT
-		bool prev_permutation(BidirectionalIterator first, BidirectionalIterator last, Compare comp)
-	{
-		if(first == last){
-			return false;	// No data
-		}
-		BidirectionalIterator i = last;
-		--i;
-		if(i == first){
-			return false;	//Only one element
-		}
-		BidirectionalIterator ii = i;
-		--ii;
-		//If the last two items are in reverse order, swap them and call it done
-		if( comp(*i, *ii) ){
-			iter_swap(ii, i);
-			return true;
-		}
-
-		//Copied from GNU GCC header files version 3.4.2
-		i = last;
-		--i;
-
-		for(;;){
-			ii = i;
-			--i;
-			if ( comp(*ii, *i)){
-				BidirectionalIterator j = last;
-				--j;
-				while ( !comp(*j, *i)){
-					--j;
-				}
-				iter_swap(i, j);
-				reverse(ii, last);
-				return true;
-			}
-			if (i == first){
-				reverse(first, last);
-				return false;
-			}
-		}
-
-	}
-
-}
+extern "C++"
+{
+
+namespace std
+{
+
+  // Subclause _lib.alg.nonmodifying_, non-modifying sequence operations:
+
+  template<class InputIterator, class Function> _UCXXEXPORT
+    Function for_each(InputIterator first, InputIterator last, Function f)
+  {
+    while (first !=last)
+    {
+      f(*first);
+      ++first;
+    }
+
+    return f;
+  }
+
+  template<class InputIterator, class T> _UCXXEXPORT
+    InputIterator find(InputIterator first, InputIterator last, const T& value)
+  {
+    while (first !=last && *first != value)
+    {
+      ++first;
+    }
+
+    return first;
+  }
+
+  template<class InputIterator, class Predicate> _UCXXEXPORT
+    InputIterator find_if (InputIterator first, InputIterator last, Predicate pred)
+  {
+    while (first !=last && !pred(*first))
+    {
+      ++first;
+    }
+
+    return first;
+  }
+
+  template<class ForwardIterator1, class ForwardIterator2> _UCXXEXPORT ForwardIterator1
+    find_end(ForwardIterator1 first1, ForwardIterator1 last1,
+      ForwardIterator2 first2, ForwardIterator2 last2)
+  {
+    ForwardIterator1 retval = last1;
+    while (first1 != last1)
+    {
+      ForwardIterator1 temp1(first1);
+      ForwardIterator2 temp2(first2);
+
+      while (temp2!=last2 && temp1!= last1)
+      {
+        if (*temp1 != *temp2)
+        {
+          break;    //Exit while loop
+        }
+
+        ++temp1;
+        ++temp2;
+        if (temp2 == last2)
+        {
+          //Have successfully checked the whole sequence
+
+          retval = first1;
+        }
+      }
+    }
+
+    return retval;
+  }
+
+  template<class ForwardIterator1, class ForwardIterator2, class BinaryPredicate> _UCXXEXPORT
+    ForwardIterator1
+    find_end(ForwardIterator1 first1, ForwardIterator1 last1,
+      ForwardIterator2 first2, ForwardIterator2 last2,
+      BinaryPredicate pred)
+  {
+    ForwardIterator1 retval = last1;
+    while (first1 !=last1)
+    {
+      ForwardIterator1 temp1(first1);
+      ForwardIterator2 temp2(first2);
+      while (temp2!=last2 && temp1!= last1)
+      {
+        if (!pred(*temp1, *temp2))
+        {
+          break;    //Exit while loop
+        }
+
+        ++temp1;
+        ++temp2;
+        if (temp2 == last2)
+        {
+          // Have successfully checked the whole sequence
+
+          retval = first1;
+        }
+      }
+    }
+
+    return retval;
+  }
+
+  template<class ForwardIterator1, class ForwardIterator2> _UCXXEXPORT
+    ForwardIterator1
+    find_first_of(ForwardIterator1 first1, ForwardIterator1 last1,
+      ForwardIterator2 first2, ForwardIterator2 last2)
+  {
+    while (first1 != last1)
+    {
+      ForwardIterator2 temp2(first2);
+      while (temp2 != last2)
+      {
+        if (*temp2 == first1)
+        {
+          return first1;
+        }
+
+        ++temp2;
+      }
+    }
+
+    return last1;
+  }
+
+  template<class ForwardIterator1, class ForwardIterator2, class BinaryPredicate> _UCXXEXPORT
+    ForwardIterator1
+    find_first_of(ForwardIterator1 first1, ForwardIterator1 last1,
+      ForwardIterator2 first2, ForwardIterator2 last2,
+      BinaryPredicate pred)
+  {
+    while (first1 != last1)
+    {
+      ForwardIterator2 temp2(first2);
+      while (temp2 != last2)
+      {
+        if (*temp2 == first1)
+        {
+          return first1;
+        }
+
+        ++temp2;
+      }
+    }
+
+    return last1;
+  }
+
+  template<class ForwardIterator> _UCXXEXPORT ForwardIterator
+    adjacent_find(ForwardIterator first, ForwardIterator last)
+  {
+    ForwardIterator temp;
+    while (first != last)
+    {
+      temp = first;
+      ++temp;
+      if (*temp == *first)
+      {
+        return first;
+      }
+
+      ++first;
+    }
+
+    return first;
+  }
+
+  template<class ForwardIterator, class BinaryPredicate> _UCXXEXPORT
+    ForwardIterator
+    adjacent_find(ForwardIterator first, ForwardIterator last, BinaryPredicate pred)
+  {
+    ForwardIterator temp;
+    while (first != last)
+    {
+      temp = first;
+      ++temp;
+      if (pred(*temp, *first))
+      {
+        return first;
+      }
+
+      ++first;
+    }
+
+    return first;
+  }
+
+  template<class InputIterator, class T> _UCXXEXPORT
+    typename iterator_traits<InputIterator>::difference_type
+    count(InputIterator first, InputIterator last, const T& value)
+  {
+    typename iterator_traits<InputIterator>::difference_type i = 0;
+    while (first!=last)
+    {
+      if (*first == value)
+      {
+        ++i;
+      }
+
+      ++first;
+    }
+
+    return i;
+  }
+
+  template<class InputIterator, class Predicate> _UCXXEXPORT
+    typename iterator_traits<InputIterator>::difference_type
+    count_if (InputIterator first, InputIterator last, Predicate pred)
+  {
+    typename iterator_traits<InputIterator>::difference_type i = 0;
+    while (first!=last)
+    {
+      if (pred(*first))
+      {
+        ++i;
+      }
+
+      ++first;
+    }
+
+    return i;
+  }
+
+  template<class InputIterator1, class InputIterator2> _UCXXEXPORT
+    pair<InputIterator1, InputIterator2>
+    mismatch(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2)
+  {
+    while (first1 != last1)
+    {
+      if (*first1 != *first2)
+      {
+        break;
+      }
+
+      ++first1;
+      ++first2;
+    }
+
+    pair<InputIterator1, InputIterator2> retval;
+    retval.first = first1;
+    retval.second = first2;
+    return retval;
+  }
+
+  template<class InputIterator1, class InputIterator2, class BinaryPredicate> _UCXXEXPORT
+    pair<InputIterator1, InputIterator2>
+    mismatch(InputIterator1 first1, InputIterator1 last1,
+      InputIterator2 first2, BinaryPredicate pred)
+  {
+    while (first1 != last1)
+    {
+      if (!pred(*first1, *first2))
+      {
+        break;
+      }
+
+      ++first1;
+      ++first2;
+    }
+
+    pair<InputIterator1, InputIterator2> retval;
+    retval.first = first1;
+    retval.second = first2;
+    return retval;
+  }
+
+  template<class InputIterator1, class InputIterator2> _UCXXEXPORT
+    bool
+    equal(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2)
+  {
+    while (first1 !=last1)
+    {
+      if (*first1 != *first2)
+      {
+        return false;
+      }
+
+      ++first1;
+      ++first2;
+    }
+
+    return true;
+  }
+
+  template<class InputIterator1, class InputIterator2, class BinaryPredicate> _UCXXEXPORT
+    bool
+    equal(InputIterator1 first1, InputIterator1 last1,
+      InputIterator2 first2, BinaryPredicate pred)
+  {
+    while (first1 !=last1)
+    {
+      if (!pred(*first1, *first2))
+      {
+        return false;
+      }
+
+      ++first1;
+      ++first2;
+    }
+
+    return true;
+  }
+
+  template<class ForwardIterator1, class ForwardIterator2> _UCXXEXPORT
+    ForwardIterator1 search(ForwardIterator1 first1, ForwardIterator1 last1,
+      ForwardIterator2 first2, ForwardIterator2 last2)
+  {
+    equal_to<typename iterator_traits<ForwardIterator1>::value_type> c;
+    return search(first1, last1, first2, last2, c);
+  }
+
+  template<class ForwardIterator1, class ForwardIterator2, class BinaryPredicate> _UCXXEXPORT
+    ForwardIterator1
+    search(ForwardIterator1 first1, ForwardIterator1 last1,
+      ForwardIterator2 first2, ForwardIterator2 last2,
+      BinaryPredicate pred)
+  {
+    while (first1 != last1)
+    {
+      ForwardIterator1 temp1(first1);
+      ForwardIterator2 temp2(first2);
+      while (temp2 != last2 && temp1 != last1)
+      {
+        if (!pred(*temp2, *temp1))
+        {
+          break;
+        }
+
+        ++temp1;
+        ++temp2;
+        if (temp2 == last2)
+        {
+          return first1;
+        }
+      }
+
+      ++first1;
+    }
+
+    return last1;
+  }
+
+
+  template<class ForwardIterator, class Size, class T> _UCXXEXPORT
+    ForwardIterator
+    search_n(ForwardIterator first, ForwardIterator last, Size count, const T& value)
+  {
+    while (first != last)
+    {
+      if (*first == value)
+      {
+        ForwardIterator temp(first);
+        Size i = 1;
+        ++first;  // Avoid doing the same comparison over again
+        while (i < count && *temp == value)
+        {
+          ++first;
+          ++i;
+        }
+
+        if (i == count)
+        {
+          return first;
+        }
+      }
+
+      ++first;
+    }
+
+    return first;
+  }
+
+
+  template<class ForwardIterator, class Size, class T, class BinaryPredicate> _UCXXEXPORT
+    ForwardIterator
+    search_n(ForwardIterator first, ForwardIterator last,
+      Size count, const T& value, BinaryPredicate pred)
+  {
+    while (first != last)
+    {
+      if (pred(*first, value))
+      {
+        ForwardIterator temp(first);
+        Size i = 1;
+        ++first;  // Avoid doing the same comparison over again
+        while (i < count && pred(*temp, value))
+        {
+          ++first;
+          ++i;
+        }
+
+        if (i == count)
+        {
+          return first;
+        }
+      }
+      
+      ++first;
+    }
+    
+    return first;
+  }
+
+  // Subclause _lib.alg.modifying.operations_, modifying sequence operations:
+
+  template<class InputIterator, class OutputIterator> _UCXXEXPORT
+    OutputIterator
+    copy(InputIterator first, InputIterator last, OutputIterator result)
+  {
+    while (first != last)
+    {
+      *result = *first;
+      ++first;
+      ++result;
+    }
+
+    return result;
+  }
+
+  template<class BidirectionalIterator1, class BidirectionalIterator2> _UCXXEXPORT
+    BidirectionalIterator2
+    copy_backward(BidirectionalIterator1 first, BidirectionalIterator1 last,
+      BidirectionalIterator2 result)
+  {
+    while (first !=last)
+    {
+      --result;
+      --last;
+      *result = *last;
+    }
+
+    return result;
+  }
+
+  template<class T> _UCXXEXPORT void swap(T& a, T& b)
+  {
+    T temp(a);
+    a = b;
+    b = temp;
+  }
+
+  template<class ForwardIterator1, class ForwardIterator2> _UCXXEXPORT
+    ForwardIterator2
+    swap_ranges(ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2)
+  {
+    while (first1 != last1)
+    {
+      iter_swap(first1, first2);
+      ++first1;
+      ++first2;
+    }
+
+    return first2;
+  }
+
+  template<class ForwardIterator1, class ForwardIterator2> _UCXXEXPORT
+    void
+    iter_swap(ForwardIterator1 a, ForwardIterator2 b)
+  {
+    typename iterator_traits<ForwardIterator1>::value_type temp(*a);
+    *a = *b;
+    *b = temp;
+  }
+
+  template<class InputIterator, class OutputIterator, class UnaryOperation> _UCXXEXPORT
+    OutputIterator
+    transform(InputIterator first, InputIterator last,
+      OutputIterator result, UnaryOperation op)
+  {
+    while (first != last)
+    {
+      *result = op(*first);
+      ++first;
+      ++result;
+    }
+
+    return result;
+  }
+
+  template<class InputIterator1, class InputIterator2, class OutputIterator, class BinaryOperation> _UCXXEXPORT
+    OutputIterator transform(InputIterator1 first1, InputIterator1 last1,
+      InputIterator2 first2, OutputIterator result,
+      BinaryOperation binary_op)
+  {
+    while (first1 != last1)
+    {
+      *result = binary_op(*first1, *first2);
+      ++first1;
+      ++first2;
+      ++result;
+    }
+
+    return result;
+  }
+
+  template<class ForwardIterator, class T> _UCXXEXPORT
+    void
+    replace(ForwardIterator first, ForwardIterator last,
+      const T& old_value, const T& new_value)
+  {
+    while (first != last)
+    {
+      if (*first == old_value)
+      {
+        *first = new_value;
+      }
+
+      ++first;
+    }
+  }
+
+  template<class ForwardIterator, class Predicate, class T> _UCXXEXPORT
+    void
+    replace_if (ForwardIterator first, ForwardIterator last,
+      Predicate pred, const T& new_value)
+  {
+    while (first != last)
+    {
+      if (pred(*first))
+      {
+        *first = new_value;
+      }
+
+      ++first;
+    }
+  }
+
+  template<class InputIterator, class OutputIterator, class T> _UCXXEXPORT
+    OutputIterator
+    replace_copy(InputIterator first, InputIterator last,
+      OutputIterator result, const T& old_value, const T& new_value)
+  {
+    while (first != last)
+    {
+      if (*first == old_value)
+      {
+        *result = new_value;
+      }
+      else
+      {
+        *result = *first;
+      }
+
+      ++first;
+      ++result;
+    }
+
+    return result;
+  }
+
+  template<class Iterator, class OutputIterator, class Predicate, class T> _UCXXEXPORT
+    OutputIterator
+    replace_copy_if (Iterator first, Iterator last,
+      OutputIterator result, Predicate pred, const T& new_value)
+  {
+    while (first != last)
+    {
+      if (pred(*first))
+      {
+        *result = new_value;
+      }
+      else
+      {
+        *result = *first;
+      }
+
+      ++first;
+      ++result;
+    }
+
+    return result;
+  }
+
+  template<class ForwardIterator, class T> _UCXXEXPORT
+    void
+    fill(ForwardIterator first, ForwardIterator last, const T& value)
+  {
+    while (first != last)
+    {
+      *first = value;
+      ++first;
+    }
+  }
+
+  template<class OutputIterator, class Size, class T> _UCXXEXPORT
+    void
+    fill_n(OutputIterator first, Size n, const T& value)
+  {
+    while (n != 0)
+    {
+      *first = value;
+      --n;
+      ++first;
+    }
+  }
+
+  template<class ForwardIterator, class Generator> _UCXXEXPORT
+    void
+    generate(ForwardIterator first, ForwardIterator last, Generator gen)
+  {
+    while (first != last)
+    {
+      *first = gen();
+      ++first;
+    }
+  }
+
+  template<class OutputIterator, class Size, class Generator> _UCXXEXPORT
+    void
+    generate_n(OutputIterator first, Size n, Generator gen)
+  {
+    while (n !=0)
+    {
+      *first = gen();
+      --n;
+      ++first;
+    }
+  }
+
+  template<class ForwardIterator, class T> _UCXXEXPORT
+    ForwardIterator
+    remove(ForwardIterator first, ForwardIterator last, const T& value)
+  {
+    ForwardIterator temp(first);
+    while (temp !=last)
+    {
+      if (*temp == value)
+      {
+
+      }
+      else
+      {
+        *first = *temp;
+        ++first;
+      }
+
+      ++temp;
+    }
+
+    return first;
+  }
+
+  template<class ForwardIterator, class Predicate> _UCXXEXPORT
+    ForwardIterator
+    remove_if (ForwardIterator first, ForwardIterator last, Predicate pred)
+  {
+    ForwardIterator temp(first);
+    while (temp !=last)
+    {
+      if (pred(*temp))
+      {
+      }
+      else
+      {
+        *first = *temp;
+        ++first;
+      }
+
+      ++temp;
+    }
+
+    return first;
+  }
+
+  template<class InputIterator, class OutputIterator, class T> _UCXXEXPORT
+    OutputIterator
+    remove_copy(InputIterator first, InputIterator last,
+      OutputIterator result, const T& value)
+  {
+    while (first !=last)
+    {
+      if (*first != value)
+      {
+        *result = *first;
+        ++result;
+      }
+
+      ++first;
+    }
+
+    return result;
+  }
+
+  template<class InputIterator, class OutputIterator, class Predicate> _UCXXEXPORT
+    OutputIterator
+    remove_copy_if (InputIterator first, InputIterator last,
+      OutputIterator result, Predicate pred)
+  {
+    while (first !=last)
+    {
+      if (!pred(*first))
+      {
+        *result = *first;
+        ++result;
+      }
+
+      ++first;
+    }
+
+    return result;
+  }
+
+  template<class ForwardIterator> _UCXXEXPORT
+    ForwardIterator
+    unique(ForwardIterator first, ForwardIterator last)
+  {
+    ForwardIterator new_val(first);
+    ForwardIterator old_val(first);
+
+    while (new_val !=last)
+    {
+      if (*new_val == *old_val && new_val != old_val)
+      {
+      }
+      else
+      {
+        *first = *new_val;
+        old_val = new_val;
+        ++first;
+      }
+
+      ++new_val;
+    }
+
+    return first;
+  }
+
+  template<class ForwardIterator, class BinaryPredicate> _UCXXEXPORT
+    ForwardIterator
+    unique(ForwardIterator first, ForwardIterator last, BinaryPredicate pred)
+  {
+    ForwardIterator new_val(first);
+    ForwardIterator old_val(first);
+
+    while (new_val !=last)
+    {
+      if (pred(*new_val, *old_val) && new_val != old_val)
+      {
+      }
+      else
+      {
+        *first = *new_val;
+        old_val = new_val;
+        ++first;
+      }
+
+      ++new_val;
+    }
+
+    return first;
+  }
+
+  template<class InputIterator, class OutputIterator> _UCXXEXPORT
+    OutputIterator
+    unique_copy(InputIterator first, InputIterator last, OutputIterator result)
+  {
+    InputIterator temp(first);
+    while (first !=last)
+    {
+      if (*first == *temp && first != temp)
+      {
+      }
+      else
+      {
+        *result = *first;
+        temp = first;
+        ++result;
+      }
+
+      ++first;
+    }
+
+    return result;
+  }
+
+  template<class InputIterator, class OutputIterator, class BinaryPredicate> _UCXXEXPORT
+    OutputIterator
+    unique_copy(InputIterator first, InputIterator last,
+      OutputIterator result, BinaryPredicate pred)
+  {
+    InputIterator temp(first);
+    while (first !=last)
+    {
+      if (pred(*first, *temp) && first != temp)
+      {
+      }
+      else
+      {
+        *result = *first;
+        temp = first;
+        ++result;
+      }
+
+      ++first;
+    }
+
+    return result;
+  }
+
+  template<class BidirectionalIterator> _UCXXEXPORT
+    void
+    reverse(BidirectionalIterator first, BidirectionalIterator last)
+  {
+    --last;    //Don't work with one past the end element
+    while (first < last)
+    {
+      iter_swap(first, last);
+      ++first;
+      --last;
+    }
+  }
+
+  template<class BidirectionalIterator, class OutputIterator> _UCXXEXPORT
+    OutputIterator
+    reverse_copy(BidirectionalIterator first, BidirectionalIterator last,
+    OutputIterator result)
+  {
+    while (last > first)
+    {
+      --last;
+      *result = *last;
+      ++result;
+    }
+
+    return result;
+  }
+
+  template<class ForwardIterator> _UCXXEXPORT
+    void
+    rotate(ForwardIterator first, ForwardIterator middle, ForwardIterator last)
+  {
+    if ((first == middle) || (last  == middle))
+    {
+      return;
+    }
+
+    ForwardIterator first2 = middle;
+
+    do
+    {
+      swap(*first, *first2);
+      first++;
+      first2++;
+      if (first == middle)
+      {
+        middle = first2;
+      }
+    }
+    while (first2 != last);
+
+    first2 = middle;
+
+    while (first2 != last)
+    {
+      swap(*first, *first2);
+      first++;
+      first2++;
+      if (first == middle)
+      {
+        middle = first2;
+      }
+      else if (first2 == last)
+      {
+        first2 = middle;
+      }
+    }
+  }
+
+  template<class ForwardIterator, class OutputIterator> _UCXXEXPORT
+    OutputIterator
+    rotate_copy(ForwardIterator first, ForwardIterator middle,
+      ForwardIterator last, OutputIterator result)
+  {
+    ForwardIterator temp(middle);
+    while (temp !=last)
+    {
+      *result = *temp;
+      ++temp;
+      ++result;
+    }
+
+    while (first != middle)
+    {
+      *result = *first;
+      ++first;
+      ++result;
+    }
+
+    return result;
+  }
+
+  template<class RandomAccessIterator> _UCXXEXPORT
+    void
+    random_shuffle(RandomAccessIterator first, RandomAccessIterator last)
+  {
+    --last;
+    while (first != last)
+    {
+      iter_swap(first, (first + (rand() % (last - first))));
+      ++first;
+    }
+  }
+
+  template<class RandomAccessIterator, class RandomNumberGenerator> _UCXXEXPORT
+    void
+    random_shuffle(RandomAccessIterator first, RandomAccessIterator last,
+    RandomNumberGenerator& rand)
+  {
+    --last;
+    while (first != last)
+    {
+      iter_swap(first, (first + (rand(last - first))));
+      ++first;
+    }
+  }
+
+  // _lib.alg.partitions_, partitions:
+
+  template<class BidirectionalIterator, class Predicate> _UCXXEXPORT BidirectionalIterator
+    partition(BidirectionalIterator first, BidirectionalIterator last, Predicate pred)
+  {
+    return stable_partition(first, last, pred);
+  }
+
+  template<class BidirectionalIterator, class Predicate> _UCXXEXPORT BidirectionalIterator
+    stable_partition(BidirectionalIterator first, BidirectionalIterator last, Predicate pred)
+  {
+    // First now points to the first non-desired element
+
+    while (first != last && pred(*first)){
+      ++first;
+    }
+
+    BidirectionalIterator tempb;
+    BidirectionalIterator tempe = first;
+
+    while (tempe != last)
+    {
+      //Find the next desired element
+
+      while (!pred(*tempe))
+      {
+        ++tempe;
+
+        //See if we should exit
+
+        if (tempe == last)
+        {
+          return first;
+        }
+      }
+
+      // Rotate the element back to the begining
+
+      tempb = tempe;
+      while (tempb != first)
+      {
+        iter_swap(tempb, tempb-1);
+        --tempb;
+      }
+
+      // First now has a desired element
+
+      ++first;
+    }
+
+    return first;
+  }
+
+  template<class RandomAccessIterator> _UCXXEXPORT
+    void sort(RandomAccessIterator first, RandomAccessIterator last)
+  {
+    less<typename iterator_traits<RandomAccessIterator>::value_type> c;
+    sort(first, last, c);
+  }
+
+  template<class RandomAccessIterator, class Compare> _UCXXEXPORT
+    void sort(RandomAccessIterator first, RandomAccessIterator last, Compare comp)
+  {
+    stable_sort(first, last, comp);
+  }
+
+  template<class RandomAccessIterator> _UCXXEXPORT
+    void stable_sort(RandomAccessIterator first, RandomAccessIterator last)
+  {
+    less<typename iterator_traits<RandomAccessIterator>::value_type> c;
+    stable_sort(first, last, c);
+  }
+
+  template<class RandomAccessIterator, class Compare> _UCXXEXPORT
+    void stable_sort(RandomAccessIterator first, RandomAccessIterator last, Compare comp)
+  {
+    //FIXME - bubble sort
+
+    RandomAccessIterator temp;
+    --last;
+    while (last - first > 0)
+    {
+      temp = last;
+      while (temp != first)
+      {
+        if (comp(*temp, *(temp-1)))
+        {
+          iter_swap(temp-1, temp);
+        }
+
+        --temp;
+      }
+
+      ++first;
+    }
+  }
+
+  template<class RandomAccessIterator> _UCXXEXPORT
+    void partial_sort(RandomAccessIterator first, RandomAccessIterator middle, RandomAccessIterator last)
+  {
+    less<typename iterator_traits<RandomAccessIterator>::value_type> c;
+    partial_sort(first, middle, last, c);
+  }
+
+  template<class RandomAccessIterator, class Compare> _UCXXEXPORT
+    void partial_sort(RandomAccessIterator first, RandomAccessIterator middle,
+      RandomAccessIterator last, Compare comp)
+  {
+    //Fixme - partial bubble sort
+
+    RandomAccessIterator temp;
+    --last;
+    while (first < middle)
+    {
+      temp = last;
+      while (temp != first)
+      {
+        if (comp(*temp, *(temp -1)))
+        {
+          iter_swap(temp-1, temp);
+        }
+
+        --temp;
+      }
+
+      ++first;
+    }
+  }
+
+  template<class InputIterator, class RandomAccessIterator> _UCXXEXPORT
+    RandomAccessIterator
+    partial_sort_copy(InputIterator first, InputIterator last,
+      RandomAccessIterator result_first, RandomAccessIterator result_last)
+  {
+    less<typename iterator_traits<RandomAccessIterator>::value_type> c;
+    return partial_sort_copy(first, last, result_first, result_last, c);
+  }
+
+  template<class InputIterator, class RandomAccessIterator, class Compare> _UCXXEXPORT
+    RandomAccessIterator
+    partial_sort_copy(InputIterator first, InputIterator last,
+      RandomAccessIterator result_first, RandomAccessIterator result_last, Compare comp)
+  {
+    size_t output_size = last-first;
+    size_t temp_size = result_last - result_first;
+    if (temp_size < output_size)
+    {
+      output_size = temp_size;
+    }
+
+    RandomAccessIterator middle = result_first + output_size;
+    RandomAccessIterator temp = result_first;
+
+    while (temp != middle)
+    {
+      *temp = *first;
+      ++temp;
+      ++first;
+    }
+
+    sort(result_first, middle, comp);
+
+    while (first != last)
+    {
+      if (comp(*first, *(middle-1)))
+      {
+        *(middle-1) = *first;
+        sort(result_first, middle, comp);
+      }
+
+      ++first;
+    }
+
+    return middle;
+  }
+
+  template<class RandomAccessIterator> _UCXXEXPORT
+    void nth_element(RandomAccessIterator first, RandomAccessIterator nth, RandomAccessIterator last)
+  {
+    less<typename iterator_traits<RandomAccessIterator>::value_type> c;
+    nth_element(first, nth, last, c);
+  }
+
+  template<class RandomAccessIterator, class Compare> _UCXXEXPORT
+    void nth_element(RandomAccessIterator first, RandomAccessIterator nth,
+      RandomAccessIterator last, Compare comp)
+  {
+    partial_sort(first, nth, last, comp);
+  }
+
+  template<class ForwardIterator, class T> _UCXXEXPORT
+    ForwardIterator lower_bound(ForwardIterator first, ForwardIterator last,
+      const T& value)
+  {
+    less<typename iterator_traits<ForwardIterator>::value_type> c;
+    return lower_bound(first, last, value, c);
+  }
+
+  template<class ForwardIterator, class T, class Compare> _UCXXEXPORT
+    ForwardIterator lower_bound(ForwardIterator first, ForwardIterator last,
+      const T& value, Compare comp)
+  {
+    if (first == last)
+    {
+      return last;
+    }
+
+    // If below or equal to the first element
+
+    if (comp(*first, value) == false)
+    {
+      return first;
+    }
+
+    ForwardIterator middle;
+
+    // If greater than the top element
+
+    middle = first;
+    advance(middle, distance(first, last) - 1);
+    if (comp(*middle, value))
+    {
+      return last;
+    }
+
+    // Now begin the actual search for the begining
+
+    while (distance(first, last) > 1)
+    {
+      // Find middle
+
+      middle = first;
+      advance(middle, (distance(first, last)/2));
+      if (!comp(*middle, value))
+      {
+        last = middle;
+      }
+      else
+      {
+        first = middle;
+      }
+    }
+
+    if (!comp(*first, value))
+    {
+      return first;
+    }
+
+    return last;
+  }
+
+  template<class ForwardIterator, class T> _UCXXEXPORT
+    ForwardIterator upper_bound(ForwardIterator first, ForwardIterator last,
+      const T& value)
+  {
+    less<typename iterator_traits<ForwardIterator>::value_type> c;
+    return upper_bound(first, last, value, c);
+  }
+
+  template<class ForwardIterator, class T, class Compare> _UCXXEXPORT
+    ForwardIterator upper_bound(ForwardIterator first, ForwardIterator last,
+      const T& value, Compare comp)
+  {
+    if (first == last)
+    {
+      return last;
+    }
+
+    // If below the first element
+
+    if (comp(value, *first) == true)
+    {
+      return first;
+    }
+
+    ForwardIterator middle;
+
+    // If greater than the top element
+
+    middle = first;
+    advance(middle, distance(first, last) - 1);
+    if (comp(*middle, value))
+    {
+      return last;
+    }
+
+    // Now begin the actual search for the end
+
+    while (distance(first, last) > 1)
+    {
+      // Find middle
+
+      middle = first;
+      advance(middle, (distance(first, last)/2));
+      if (comp(value, *middle))
+      {
+        last = middle;
+      }
+      else
+      {
+        first = middle;
+      }
+    }
+
+    if (comp(value, *first))
+    {
+      return first;
+    }
+
+    return last;
+  }
+
+  template<class ForwardIterator, class T> _UCXXEXPORT
+    pair<ForwardIterator, ForwardIterator>
+    equal_range(ForwardIterator first, ForwardIterator last, const T& value)
+  {
+    less<typename iterator_traits<ForwardIterator>::value_type> c;
+    return equal_range(first, last, value, c);
+  }
+
+  template<class ForwardIterator, class T, class Compare> _UCXXEXPORT
+    pair<ForwardIterator, ForwardIterator>
+    equal_range(ForwardIterator first, ForwardIterator last, const T& value, Compare comp)
+  {
+    pair<ForwardIterator, ForwardIterator> retval;
+    retval.first = lower_bound(first, last, value, comp);
+
+    //Reuse retval.first in order to (possibly) save a few comparisons
+
+    retval.second = upper_bound(retval.first, last, value, comp);
+    return retval;
+
+  }
+
+  template<class ForwardIterator, class T> _UCXXEXPORT
+    bool binary_search(ForwardIterator first, ForwardIterator last,
+      const T& value)
+  {
+    less<typename iterator_traits<ForwardIterator>::value_type> c;
+    return binary_search(first, last, value, c);
+  }
+
+  template<class ForwardIterator, class T, class Compare> _UCXXEXPORT
+    bool binary_search(ForwardIterator first, ForwardIterator last,
+      const T& value, Compare comp)
+  {
+    if (distance(first, last) == 0)
+    {
+      return false;
+    }
+
+    ForwardIterator middle;
+
+    while (distance(first, last) > 1)
+    {
+      //Set middle between first and last
+
+      middle = first;
+      advance(middle, distance(first, last)/2);
+
+      if (comp(*middle, value) == true)
+      {
+        first = middle;
+      }
+      else
+      {
+        last = middle;
+      }
+    }
+
+    if (!comp(*first, value) && !comp(value, *first))
+    {
+      return true;
+    }
+
+    if (!comp(*last, value) && !comp(value, *last))
+    {
+      return true;
+    }
+
+    return false;
+  }
+
+  // _lib.alg.merge_, merge:
+
+  template<class InputIterator1, class InputIterator2, class OutputIterator> _UCXXEXPORT
+    OutputIterator
+    merge(InputIterator1 first1, InputIterator1 last1,
+      InputIterator2 first2, InputIterator2 last2, OutputIterator result)
+  {
+    less<typename iterator_traits<InputIterator1>::value_type> c;
+    return merge(first1, last1, first2, last2, result, c);
+  }
+
+  template<class InputIterator1, class InputIterator2, class OutputIterator, class Compare> _UCXXEXPORT
+    OutputIterator
+    merge(InputIterator1 first1, InputIterator1 last1,
+      InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp)
+  {
+    while (first1 != last1 && first2 != last2)
+    {
+      //If in this order so first1 elements which are equal come first
+
+      if (comp(*first2, *first1))
+      {
+        *result = *first2;
+        ++first2;
+      }
+      else
+      {
+        *result = *first1;
+        ++first1;
+      }
+
+      ++result;
+    }
+
+    //Clean up remaining elements
+
+    while (first1 != last1)
+    {
+      *result = *first1;
+      ++first1;
+      ++result;
+    }
+
+    while (first2 != last2)
+    {
+      *result = *first2;
+      ++first2;
+      ++result;
+    }
+
+    return result;
+  }
+
+  template<class BidirectionalIterator> _UCXXEXPORT
+    void inplace_merge(BidirectionalIterator first,
+      BidirectionalIterator middle, BidirectionalIterator last)
+  {
+    less<typename iterator_traits<BidirectionalIterator>::value_type> c;
+    inplace_merge(first, middle, last, c);
+  }
+
+  template<class BidirectionalIterator, class Compare> _UCXXEXPORT
+    void inplace_merge(BidirectionalIterator first,
+      BidirectionalIterator middle, BidirectionalIterator last, Compare comp)
+  {
+    //FIXME - using a bubble exchange method
+
+    while (first != middle && middle !=last)
+    {
+      if (comp(*middle, *first))
+      {
+        BidirectionalIterator temp(middle);
+        while (temp != first)
+        {
+          iter_swap(temp, temp-1);
+          --temp;
+        }
+
+        ++middle;
+      }
+
+      ++first;
+    }
+  }
+
+  // _lib.alg.set.operations_, set operations:
+
+  template<class InputIterator1, class InputIterator2> _UCXXEXPORT
+    bool includes(InputIterator1 first1, InputIterator1 last1,
+      InputIterator2 first2, InputIterator2 last2)
+  {
+    less<typename iterator_traits<InputIterator1>::value_type> c;
+    return includes(first1, last1, first2, last2, c);
+  }
+
+  template<class InputIterator1, class InputIterator2, class Compare> _UCXXEXPORT
+    bool includes(InputIterator1 first1, InputIterator1 last1,
+      InputIterator2 first2, InputIterator2 last2, Compare comp)
+  {
+    while (first2 != last2)
+    {
+      //Advance the large set until no longer smaller than the element we are looking for
+
+      while (comp(*first1, *first2))
+      {
+        ++first1;
+
+        // If we are at the end of the list, we don't have the desired element
+
+        if (first1 == last1)
+        {
+          return false;
+        }
+      }
+
+      // If we are past the element we want, it isn't here
+
+      if (comp(*first2, *first1))
+      {
+        return false;
+      }
+
+      ++first2;  //Move to next element
+    }
+
+    return true;
+  }
+
+  template<class InputIterator1, class InputIterator2, class OutputIterator> _UCXXEXPORT
+    OutputIterator set_union(InputIterator1 first1, InputIterator1 last1,
+      InputIterator2 first2, InputIterator2 last2, OutputIterator result)
+  {
+    less<typename iterator_traits<InputIterator1>::value_type> c;
+    return set_union(first1, last1, first2, last2, result, c);
+  }
+
+  template<class InputIterator1, class InputIterator2, class OutputIterator, class Compare> _UCXXEXPORT
+    OutputIterator set_union(InputIterator1 first1, InputIterator1 last1,
+      InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp)
+  {
+    while (first1 != last1 && first2 != last2)
+    {
+      if (comp(*first2, *first1))
+      {
+        *result = *first2;
+
+        // Eliminate duplicates
+
+        InputIterator2 temp = first2;
+        while (first1 != last1 && !comp(*temp, *first1))
+        {
+          ++first1;
+        }
+
+        while (first2 != last2 && !comp(*temp, *first2))
+        {
+          ++first2;
+        }
+      }
+      else
+      {
+        *result = *first1;
+
+        // Eliminate duplicates
+
+        InputIterator1 temp = first1;
+        while (first1 != last1 && !comp(*temp, *first1))
+        {
+          ++first1;
+        }
+
+        while (first2 != last2 && !comp(*temp, *first2))
+        {
+          ++first2;
+        }
+      }
+      ++result;
+    }
+
+    // Clean up remaining elements
+
+    while (first1 != last1)
+    {
+      *result = *first1;
+      ++result;
+      InputIterator1 temp = first1;
+      while (first1 != last1 && !comp(*temp, *first1))
+      {
+        ++first1;
+      }
+    }
+
+    while (first2 != last2)
+    {
+      *result = *first2;
+      ++result;
+      InputIterator2 temp = first2;
+      while (first2 != last2 && !comp(*temp, *first2))
+      {
+        ++first2;
+      }
+    }
+
+    return result;
+  }
+
+  template<class InputIterator1, class InputIterator2, class OutputIterator> _UCXXEXPORT
+    OutputIterator set_intersection(InputIterator1 first1, InputIterator1 last1,
+      InputIterator2 first2, InputIterator2 last2, OutputIterator result)
+  {
+    less<typename iterator_traits<InputIterator1>::value_type> c;
+    return set_intersection(first1, last1, first2, last2, result, c);
+  }
+
+  template<class InputIterator1, class InputIterator2, class OutputIterator, class Compare> _UCXXEXPORT
+    OutputIterator set_intersection(InputIterator1 first1, InputIterator1 last1,
+      InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp)
+  {
+    while (first1 != last1 && first2 != last2)
+    {
+      if (comp(*first2, *first1))
+      {
+        ++first2;
+      }
+      else if (comp(*first1, *first2))
+      {
+        ++first1;
+      }
+      else
+      {
+        *result = *first1;
+        ++result;
+        InputIterator1 temp = first1;
+        while (first1 != last1 && !comp(*temp, *first1))
+        {
+          ++first1;
+        }
+
+        ++first2;
+      }
+    }
+
+    return result;
+  }
+
+  template<class InputIterator1, class InputIterator2, class OutputIterator> _UCXXEXPORT
+    OutputIterator set_difference(InputIterator1 first1, InputIterator1 last1,
+      InputIterator2 first2, InputIterator2 last2, OutputIterator result)
+  {
+    less<typename iterator_traits<InputIterator1>::value_type> c;
+    return set_difference(first1, last1, first2, last2, result, c);
+  }
+
+  template<class InputIterator1, class InputIterator2, class OutputIterator, class Compare> _UCXXEXPORT
+    OutputIterator set_difference(InputIterator1 first1, InputIterator1 last1,
+      InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp)
+  {
+    while (first1 != last1 && first2 != last2)
+    {
+      if (comp(*first1, *first2))
+      {
+        *result = *first1;
+        ++result;
+
+        // Eliminate duplicates
+
+        InputIterator1 temp = first1;
+        while (first1 != last1 && !comp(*temp, *first1))
+        {
+          ++first1;
+        }
+      }
+      else if (comp(*first2, *first1))
+      {
+        // Eliminate duplicates
+
+        InputIterator2 temp = first2;
+        while (first2 != last2 && !comp(*temp, *first2))
+        {
+          ++first2;
+        }
+
+      }
+      else
+      {
+        //They are identical - skip
+        // Eliminate duplicates
+
+        InputIterator1 temp = first1;
+        while (first1 != last1 && !comp(*temp, *first1))
+        {
+          ++first1;
+        }
+
+        while (first2 != last2 && !comp(*temp, *first2))
+        {
+          ++first2;
+        }
+      }
+    }
+
+    // Clean up remaining elements
+
+    while (first1 != last1)
+    {
+      *result = *first1;
+      ++result;
+      InputIterator1 temp = first1;
+      while (first1 != last1 && !comp(*temp, *first1))
+      {
+        ++first1;
+      }
+    }
+
+    return result;
+  }
+
+  template<class InputIterator1, class InputIterator2, class OutputIterator> _UCXXEXPORT
+    OutputIterator set_symmetric_difference(InputIterator1 first1, InputIterator1 last1,
+      InputIterator2 first2, InputIterator2 last2, OutputIterator result)
+  {
+    less<typename iterator_traits<InputIterator1>::value_type> c;
+    return set_symmetric_difference(first1, last1, first2, last2, result, c);
+  }
+
+  template<class InputIterator1, class InputIterator2, class OutputIterator, class Compare> _UCXXEXPORT
+    OutputIterator set_symmetric_difference(InputIterator1 first1, InputIterator1 last1,
+      InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp)
+  {
+    while (first1 != last1 && first2 != last2)
+    {
+      if (comp(*first1, *first2))
+      {
+        *result = *first1;
+        ++result;
+
+        // Eliminate duplicates
+
+        InputIterator1 temp = first1;
+        while (first1 != last1 && !comp(*temp, *first1))
+        {
+          ++first1;
+        }
+      }
+      else if (comp(*first2, *first1))
+      {
+        *result = *first2;
+        ++result;
+
+        // Eliminate duplicates
+
+        InputIterator2 temp = first2;
+        while (first2 != last2 && !comp(*temp, *first2))
+        {
+          ++first2;
+        }
+
+      }
+      else
+      {
+        //They are identical - skip
+        // Eliminate duplicates
+
+        InputIterator1 temp = first1;
+        while (first1 != last1 && !comp(*temp, *first1))
+        {
+          ++first1;
+        }
+
+        while (first2 != last2 && !comp(*temp, *first2))
+        {
+          ++first2;
+        }
+      }
+    }
+
+    // Clean up remaining elements
+
+    while (first1 != last1)
+    {
+      *result = *first1;
+      ++result;
+      InputIterator1 temp = first1;
+      while (first1 != last1 && !comp(*temp, *first1))
+      {
+        ++first1;
+      }
+    }
+
+    while (first2 != last2)
+    {
+      *result = *first2;
+      ++result;
+      InputIterator2 temp = first2;
+      while (first2 != last2 && !comp(*temp, *first2))
+      {
+        ++first2;
+      }
+    }
+
+    return result;
+  }
+
+  // _lib.alg.heap.operations_, heap operations:
+
+  template<class RandomAccessIterator> _UCXXEXPORT
+    void push_heap(RandomAccessIterator first, RandomAccessIterator last)
+  {
+    less<typename iterator_traits<RandomAccessIterator>::value_type> c;
+    push_heap(first, last, c);
+  }
+
+  template<class RandomAccessIterator, class Compare> _UCXXEXPORT
+    void push_heap(RandomAccessIterator first, RandomAccessIterator last, Compare comp)
+  {
+    // *(last - 1) is the last element
+
+    RandomAccessIterator begin, middle, end;
+    begin = first;
+    end = last - 2;
+
+    if (last - first < 2)
+    {
+      //Empty heap
+
+      return;
+    }
+
+    if (comp(*(last-1), *end))
+    {
+      //Belongs past the end - already in place
+
+      return;
+    }
+
+    while (end - begin > 1)
+    {
+      middle = begin + ((end - begin)/2);
+      if (comp(*middle, *(last-1)))
+      {
+        end = middle;
+      }
+      else
+      {
+        begin = middle;
+      }
+    }
+
+    if (comp(*begin, *(last-1)))
+    {
+      middle = begin;
+    }
+    else
+    {
+      middle = end;
+    }
+
+    // Now all we do is swap the elements up to the begining
+
+    --last;
+
+    while (last > middle)
+    {
+      iter_swap(last, last-1);
+      --last;
+    }
+  }
+
+  template<class RandomAccessIterator> _UCXXEXPORT
+    void pop_heap(RandomAccessIterator first, RandomAccessIterator last)
+  {
+    less<typename iterator_traits<RandomAccessIterator>::value_type> c;
+    pop_heap(first, last, c);
+  }
+
+  template<class RandomAccessIterator, class Compare> _UCXXEXPORT
+    void pop_heap(RandomAccessIterator first, RandomAccessIterator last, Compare)
+  {
+    --last;
+    while (first < last)
+    {
+      iter_swap(first, first+1);
+      ++first;
+    }
+  }
+
+  template<class RandomAccessIterator> _UCXXEXPORT
+    void make_heap(RandomAccessIterator first, RandomAccessIterator last)
+  {
+    less<typename iterator_traits<RandomAccessIterator>::value_type> c;
+    make_heap(first, last, c);
+  }
+
+  template<class RandomAccessIterator, class Compare> _UCXXEXPORT
+    void make_heap(RandomAccessIterator first, RandomAccessIterator last, Compare comp)
+  {
+    sort(reverse_iterator<RandomAccessIterator>(last), reverse_iterator<RandomAccessIterator>(first), comp);
+  }
+
+  template<class RandomAccessIterator> _UCXXEXPORT
+    void sort_heap(RandomAccessIterator first, RandomAccessIterator last)
+  {
+    less<typename iterator_traits<RandomAccessIterator>::value_type> c;
+    sort_heap(first, last, c);
+  }
+
+  template<class RandomAccessIterator, class Compare> _UCXXEXPORT
+    void sort_heap(RandomAccessIterator first, RandomAccessIterator last, Compare comp)
+  {
+    sort(first, last, comp);
+  }
+
+  // _lib.alg.min.max_, minimum and maximum:
+
+  template<class T> _UCXXEXPORT
+    const T& min(const T& a, const T& b)
+  {
+    if (b < a)
+    {
+      return b;
+    }
+
+    return a;
+  }
+
+  template<class T, class Compare> _UCXXEXPORT
+    const T& min(const T& a, const T& b, Compare comp)
+  {
+    if (comp(b, a) == true)
+    {
+      return b;
+    }
+
+    return a;
+  }
+
+  template<class T> _UCXXEXPORT
+    const T& max(const T& a, const T& b)
+  {
+    if (a < b)
+    {
+      return b;
+    }
+
+    return a;
+  }
+
+  template<class T, class Compare> _UCXXEXPORT
+    const T& max(const T& a, const T& b, Compare comp)
+  {
+    if (comp(a, b))
+    {
+      return b;
+    }
+
+    return a;
+  }
+
+  template<class ForwardIterator> _UCXXEXPORT
+    ForwardIterator min_element(ForwardIterator first, ForwardIterator last)
+  {
+    less<typename iterator_traits<ForwardIterator>::value_type> c;
+    return min_element(first, last, c);
+  }
+
+  template<class ForwardIterator, class Compare> _UCXXEXPORT
+    ForwardIterator min_element(ForwardIterator first, ForwardIterator last, Compare comp)
+  {
+    ForwardIterator retval = first;
+    ++first;
+    while (first != last)
+    {
+      if (comp(*first, *retval))
+      {
+        retval = first;
+      }
+
+      ++first;
+    }
+
+    return retval;
+  }
+
+  template<class ForwardIterator> _UCXXEXPORT
+    ForwardIterator max_element(ForwardIterator first, ForwardIterator last)
+  {
+    less<typename iterator_traits<ForwardIterator>::value_type> c;
+    return max_element(first, last, c);
+  }
+
+  template<class ForwardIterator, class Compare> _UCXXEXPORT
+    ForwardIterator max_element(ForwardIterator first, ForwardIterator last, Compare comp)
+  {
+    ForwardIterator retval = first;
+    ++first;
+    while (first != last)
+    {
+      if (comp(*retval, *first))
+      {
+        retval = first;
+      }
+
+      ++first;
+    }
+
+    return retval;
+  }
+
+  template<class InputIterator1, class InputIterator2> _UCXXEXPORT
+    bool lexicographical_compare(InputIterator1 first1, InputIterator1 last1,
+      InputIterator2 first2, InputIterator2 last2)
+  {
+    less<typename iterator_traits<InputIterator1>::value_type> c;
+    return lexicographical_compare(first1, last1, first2, last2, c);
+  }
+
+  template<class InputIterator1, class InputIterator2, class Compare> _UCXXEXPORT
+    bool lexicographical_compare(InputIterator1 first1, InputIterator1 last1,
+      InputIterator2 first2, InputIterator2 last2, Compare comp)
+  {
+    while (first1 != last1 && first2 != last2)
+    {
+      if (comp(*first1, *first2))
+      {
+        return true;
+      }
+
+      if (comp(*first2, *first1))
+      {
+        return false;
+      }
+
+      ++first1;
+      ++first2;
+    }
+
+    return first1 == last1 && first2 != last2;
+  }
+
+  // _lib.alg.permutation.generators_, permutations
+
+  template<class BidirectionalIterator> _UCXXEXPORT
+    bool next_permutation(BidirectionalIterator first, BidirectionalIterator last)
+  {
+    less<typename iterator_traits<BidirectionalIterator>::value_type> c;
+    return next_permutation(first, last, c);
+  }
+
+  template<class BidirectionalIterator, class Compare> _UCXXEXPORT
+    bool next_permutation(BidirectionalIterator first, BidirectionalIterator last, Compare comp)
+  {
+    if (first == last)
+    {
+      return false;  // No data
+    }
+
+    BidirectionalIterator i = last;
+    --i;
+    if (i == first)
+    {
+      return false;  //Only one element
+    }
+
+    BidirectionalIterator ii = i;
+    --ii;
+
+    // If the last two items are in order, swap them and call it done
+
+    if (comp(*ii, *i))
+    {
+      iter_swap(ii, i);
+      return true;
+    }
+
+    // This part of the algorithm copied from G++ header files ver. 3.4.2
+
+    i = last;
+    --i;
+    for (;;)
+    {
+      ii = i;
+      --i;
+      if (comp(*i, *ii))
+      {
+        BidirectionalIterator j = last;
+        --j;
+        while (!comp(*i, *j))
+        {
+          --j;
+        }
+
+        iter_swap(i, j);
+        reverse(ii, last);
+        return true;
+      }
+
+      if (i == first)
+      {
+        reverse(first, last);
+        return false;
+      }
+    }
+  }
+
+  template<class BidirectionalIterator> _UCXXEXPORT
+    bool prev_permutation(BidirectionalIterator first, BidirectionalIterator last)
+  {
+    less<typename iterator_traits<BidirectionalIterator>::value_type> c;
+    return prev_permutation(first, last, c);
+  }
+
+  template<class BidirectionalIterator, class Compare> _UCXXEXPORT
+    bool prev_permutation(BidirectionalIterator first, BidirectionalIterator last, Compare comp)
+  {
+    if (first == last)
+    {
+      return false;  // No data
+    }
+
+    BidirectionalIterator i = last;
+    --i;
+    if (i == first)
+    {
+      return false;  //Only one element
+    }
+
+    BidirectionalIterator ii = i;
+    --ii;
+
+    // If the last two items are in reverse order, swap them and call it done
+
+    if (comp(*i, *ii))
+    {
+      iter_swap(ii, i);
+      return true;
+    }
+
+    // Copied from GNU GCC header files version 3.4.2
+
+    i = last;
+    --i;
+
+    for (;;)
+    {
+      ii = i;
+      --i;
+      if (comp(*ii, *i))
+      {
+        BidirectionalIterator j = last;
+        --j;
+        while (!comp(*j, *i))
+        {
+          --j;
+        }
+
+        iter_swap(i, j);
+        reverse(ii, last);
+        return true;
+      }
+
+      if (i == first)
+      {
+        reverse(first, last);
+        return false;
+      }
+    }
+  }
+
+} // namespace
+} // extern "C++"
 
 #pragma GCC visibility pop
 
diff --git a/misc/uClibc++/include/uClibc++/associative_base b/misc/uClibc++/include/uClibc++/associative_base
index 27ae0ef9f..67122691b 100644
--- a/misc/uClibc++/include/uClibc++/associative_base
+++ b/misc/uClibc++/include/uClibc++/associative_base
@@ -1,47 +1,46 @@
-/*	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>
+/*  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{
+extern "C++"
+{
 
+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.
+/* 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;
@@ -56,585 +55,712 @@ template<class Key, class ValueType, class Compare, class Allocator> class _UCXX
 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) { }
+  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) { }
+  __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);
-	}
+  ~__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;
+  void swap(__base_associative & x);
 
-	const key_type (*value_to_key)(const value_type);
+  Compare c;
+  std::list<value_type> backing;
 
+  const key_type (*value_to_key)(const value_type);
 };
 
-
-/*
- * Tree iterators for the base associative class
- */
+/* 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&
-	>
+  : public std::iterator<
+    bidirectional_iterator_tag,
+    ValueType,
+    typename Allocator::difference_type,
+    ValueType*,
+    ValueType&
+  >
 {
 protected:
-	typedef std::list<ValueType> listtype;
+  typedef std::list<ValueType> listtype;
+
+  typename listtype::const_iterator base_iter;
+  friend class _associative_iter<ValueType, Compare, Allocator>;
 
-	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;
-	}
+  _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&
-	>
+  : public std::iterator<
+    bidirectional_iterator_tag,
+    ValueType,
+    typename Allocator::difference_type,
+    ValueType*,
+    ValueType&
+  >
 {
 protected:
-	typedef std::list<ValueType> listtype;
+  typedef std::list<ValueType> listtype;
 
-	typename listtype::iterator base_iter;
-	typedef _associative_citer<ValueType, Compare, Allocator> __associative_citer;
+  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;
-	}
-
+  _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);
-	}
-
+  // 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>
+  public __base_associative<Key, ValueType, Compare, Allocator>
 {
 protected:
-	typedef __base_associative<Key, ValueType, Compare, Allocator> base;
-	using base::backing;
+  typedef __base_associative<Key, ValueType, Compare, Allocator> base;
+  using base::backing;
 
-	using base::c;
+  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;
-		}
-	}
-
+  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>
+  public __base_associative<Key, ValueType, Compare, Allocator>
 {
 protected:
-	typedef __base_associative<Key, ValueType, Compare, Allocator> base;
-	using base::backing;
+  typedef __base_associative<Key, ValueType, Compare, Allocator> base;
+  using base::backing;
 
-	using base::c;
+  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;
-		}
-	}
+  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;
+    }
+  }
 };
 
-
-
-
-}
+} // namespace
+} // extern "C++"
 
 #pragma GCC visibility pop
 
-#endif	//__STD_HEADER_ASSOCIATIVE_BASE
+#endif  //__STD_HEADER_ASSOCIATIVE_BASE
 
diff --git a/misc/uClibc++/include/uClibc++/bitset b/misc/uClibc++/include/uClibc++/bitset
index 50d540469..92243b208 100644
--- a/misc/uClibc++/include/uClibc++/bitset
+++ b/misc/uClibc++/include/uClibc++/bitset
@@ -1,21 +1,21 @@
-/*	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
-*/
+/*  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>
@@ -29,395 +29,551 @@
 
 #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;
-	}
-
-
-
-
-}
+extern "C++"
+{
+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;
+  }
+
+} // namespace
+} // extern "C++"
 
 #pragma GCC visibility pop
 
 #endif
-
diff --git a/misc/uClibc++/include/uClibc++/char_traits b/misc/uClibc++/include/uClibc++/char_traits
index d09de41b6..ec2900ba7 100644
--- a/misc/uClibc++/include/uClibc++/char_traits
+++ b/misc/uClibc++/include/uClibc++/char_traits
@@ -32,8 +32,7 @@
 // POSSIBILITY OF SUCH DAMAGE.
 //
 //***************************************************************************
-//#ifndef __INCLUDE_CXX_CHAR1_TRAITS
-//#define __INCLUDE_CXX_CHAR1_TRAITS
+
 #include <basic_definitions>
 #include <string.h>
 #include <exception>
@@ -47,169 +46,223 @@
 #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 strlen(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;
-		}
-	};
-
+extern "C++"
+{
+
+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 strlen(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
+  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 // __UCLIBCXX_HAS_WCHAR__
+
+} // namespace
+} // extern "C++"
+
+#endif // __HEADER_CHAR_TRAITS
diff --git a/misc/uClibc++/include/uClibc++/complex b/misc/uClibc++/include/uClibc++/complex
index 2c3c82b96..9081ec83c 100644
--- a/misc/uClibc++/include/uClibc++/complex
+++ b/misc/uClibc++/include/uClibc++/complex
@@ -1,21 +1,21 @@
-/*	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
-*/
+/*  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>
@@ -23,305 +23,411 @@
 #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);
-	}
+extern "C++"
+{
+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
 
-}
+} // namespace
+} // extern "C++"
 
 #endif
 
diff --git a/misc/uClibc++/include/uClibc++/deque b/misc/uClibc++/include/uClibc++/deque
index 19be5c8bb..48b5db3b3 100644
--- a/misc/uClibc++/include/uClibc++/deque
+++ b/misc/uClibc++/include/uClibc++/deque
@@ -1,20 +1,20 @@
 /*  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
-
-*/
+ *
+ * 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>
@@ -25,6 +25,8 @@
 #ifndef __STD_HEADER_DEQUE
 #define __STD_HEADER_DEQUE
 
+extern "C++"
+{
 namespace std
 {
   template <class T, class Allocator = allocator<T> > class deque;
@@ -1057,7 +1059,9 @@ namespace std
   template <class T, class Allocator> _UCXXEXPORT void swap(deque<T,Allocator>& x, deque<T,Allocator>& y){
     x.swap(y);
   }
+
 } // namespace
+} // extern "C++"
 
 #pragma GCC visibility pop
 
diff --git a/misc/uClibc++/include/uClibc++/fstream b/misc/uClibc++/include/uClibc++/fstream
index d5c1d083b..0f0388e5d 100644
--- a/misc/uClibc++/include/uClibc++/fstream
+++ b/misc/uClibc++/include/uClibc++/fstream
@@ -1,25 +1,24 @@
-/*	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
-*/
+/*  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>
@@ -40,637 +39,821 @@
 
 #pragma GCC visibility push(default)
 
-namespace std{
-
-	template <class C, class T> class basic_filebuf;
+extern "C++"
+{
+namespace std
+{
+  template <class C, class T> class basic_filebuf;
 
-	typedef basic_filebuf<char>    filebuf;
+  typedef basic_filebuf<char>    filebuf;
 #ifdef __UCLIBCXX_HAS_WCHAR__
-	typedef basic_filebuf<wchar_t> wfilebuf;
+  typedef basic_filebuf<wchar_t> wfilebuf;
 #endif
 
-
-	template <class charT, class traits> class _UCXXEXPORT basic_filebuf
-		: public basic_streambuf<charT,traits>
-	{
+  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
+    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[CONFIG_UCLIBCXX_IOSTREAM_BUFSIZE];
-			gbuffer = new char_type[CONFIG_UCLIBCXX_IOSTREAM_BUFSIZE];
-
-			this->setp(pbuffer, pbuffer + CONFIG_UCLIBCXX_IOSTREAM_BUFSIZE);
-			//Position get buffer so that there is no data available
-			this->setg(gbuffer, gbuffer + CONFIG_UCLIBCXX_IOSTREAM_BUFSIZE,
-				gbuffer + CONFIG_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;
-	};
+  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[CONFIG_UCLIBCXX_IOSTREAM_BUFSIZE];
+      gbuffer = new char_type[CONFIG_UCLIBCXX_IOSTREAM_BUFSIZE];
+
+      this->setp(pbuffer, pbuffer + CONFIG_UCLIBCXX_IOSTREAM_BUFSIZE);
+
+      //Position get buffer so that there is no data available
+
+      this->setg(gbuffer, gbuffer + CONFIG_UCLIBCXX_IOSTREAM_BUFSIZE,
+        gbuffer + CONFIG_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);
+  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();
+  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();
+  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 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);
+  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;
-	};
-
-
+  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_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();
+  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
 
-
-
-}
+} // namespace
+} // exteren "C++"
 
 #pragma GCC visibility pop
 
 #endif
-
diff --git a/misc/uClibc++/include/uClibc++/functional b/misc/uClibc++/include/uClibc++/functional
index b7932e2cf..e11e9f316 100644
--- a/misc/uClibc++/include/uClibc++/functional
+++ b/misc/uClibc++/include/uClibc++/functional
@@ -1,20 +1,20 @@
-/*	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
-*/
-
+/*  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
@@ -23,414 +23,466 @@
 
 #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);
-	}
-
-
-}
+extern "C++"
+{
 
+namespace std
+{
 
-//These are SGI extensions which are checked for by some conformance checks.  They
+  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);
+  }
+
+} // namespace
+
+// 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>
+  public std::unary_function<typename Op2::argument_type,
+    typename Op1::result_type>
 {
 protected:
-	Op1 mf1;
-	Op2 mf2;
+  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));
-	}
+  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);
+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>
+  public std::unary_function<typename Op2::argument_type, typename Op1::result_type>
 {
 protected:
-	Op1 mf1;
-	Op2 mf2;
-	Op3 mf3;
+  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));
-	}
+  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);
+
+compose2(const Op1 & fn1, const Op2 & fn2, const Op3 & fn3)
+{
+  return binary_compose<Op1, Op2, Op3>(fn1, fn2, fn3);
 }
 
+} // extern "C++"
+
 #pragma GCC visibility pop
 
 #endif
diff --git a/misc/uClibc++/include/uClibc++/iomanip b/misc/uClibc++/include/uClibc++/iomanip
index 14a82607c..82125268a 100644
--- a/misc/uClibc++/include/uClibc++/iomanip
+++ b/misc/uClibc++/include/uClibc++/iomanip
@@ -1,21 +1,21 @@
-/*	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
-*/
+/*  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>
@@ -25,144 +25,157 @@
 
 #pragma GCC visibility push(default)
 
-namespace std{
+extern "C++"
+{
+namespace std
+{
 
 // These are the helper classes which we are going to be using to
 // hold the required data
 
-class _UCXXEXPORT __resetiosflags{
+class _UCXXEXPORT __resetiosflags
+{
 public:
-	ios_base::fmtflags m;
-	_UCXXEXPORT __resetiosflags(ios_base::fmtflags mask) : m(mask){ }
+  ios_base::fmtflags m;
+  _UCXXEXPORT __resetiosflags(ios_base::fmtflags mask) : m(mask){ }
 };
 
-class _UCXXEXPORT __setiosflags{
+class _UCXXEXPORT __setiosflags
+{
 public:
-	ios_base::fmtflags m;
-	_UCXXEXPORT __setiosflags(ios_base::fmtflags mask) : m(mask){ }
+  ios_base::fmtflags m;
+  _UCXXEXPORT __setiosflags(ios_base::fmtflags mask) : m(mask){ }
 };
 
-class _UCXXEXPORT __setbase{
+class _UCXXEXPORT __setbase
+{
 public:
-	int base;
-	_UCXXEXPORT __setbase(int b) : base(b){ }
+  int base;
+  _UCXXEXPORT __setbase(int b) : base(b){ }
 };
 
-class _UCXXEXPORT __setfill{
+class _UCXXEXPORT __setfill
+{
 public:
-	int character;
-	_UCXXEXPORT __setfill(int c): character(c){  }
+  int character;
+  _UCXXEXPORT __setfill(int c): character(c){  }
 };
 
-class _UCXXEXPORT __setprecision{
+class _UCXXEXPORT __setprecision
+{
 public:
-	int digits;
-	_UCXXEXPORT __setprecision(int n): digits(n) {  }
+  int digits;
+  _UCXXEXPORT __setprecision(int n): digits(n) {  }
 };
 
-class _UCXXEXPORT __setw{
+class _UCXXEXPORT __setw
+{
 public:
-	int width;
-	_UCXXEXPORT __setw(int n): width(n) {  }
+  int width;
+  _UCXXEXPORT __setw(int n): width(n) {  }
 };
 
+// Actual manipulator functions
 
-//Actual manipulator functions
-
-inline __resetiosflags resetiosflags(ios_base::fmtflags mask){
-	return __resetiosflags(mask);
+inline __resetiosflags resetiosflags(ios_base::fmtflags mask)
+{
+  return __resetiosflags(mask);
 }
 
-inline __setiosflags setiosflags(ios_base::fmtflags mask){
-	return __setiosflags(mask);
+inline __setiosflags setiosflags(ios_base::fmtflags mask)
+{
+  return __setiosflags(mask);
 }
 
-inline __setbase setbase(int b){
-	return __setbase(b);
+inline __setbase setbase(int b)
+{
+  return __setbase(b);
 }
 
-inline __setfill setfill(int c){
-	return __setfill(c);
+inline __setfill setfill(int c)
+{
+  return __setfill(c);
 }
 
-inline __setprecision setprecision(int n){
-	return __setprecision(n);
+inline __setprecision setprecision(int n)
+{
+  return __setprecision(n);
 }
 
-inline __setw setw(int n){
-	return __setw(n);
+inline __setw setw(int n)
+{
+  return __setw(n);
 }
 
-
-//How to handle interaction with [i|o]stream classes
+// 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)
+  operator<<(basic_ostream<Ch, Tr>& os, const __resetiosflags s)
 {
-	os.setf(ios_base::fmtflags(0),s.m);
-	return os;
+  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)
+  operator>>(basic_istream<Ch, Tr>& is, const __resetiosflags s)
 {
-	is.setf(ios_base::fmtflags(0),s.m);
-	return is;
+  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)
+  operator<<(basic_ostream<Ch, Tr>& os, const __setiosflags s)
 {
-	os.setf(s.m);
-	return os;
+  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;
+  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)
+  operator<<(basic_ostream<Ch, Tr>& os, const __setfill s)
 {
-	os.fill(s.character);
-	return os;
+  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)
+  operator<<(basic_ostream<Ch, Tr>& os, const __setprecision s)
 {
-	os.precision(s.digits);
-	return os;
+  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)
+  operator<<(basic_ostream<Ch, Tr>& os, const __setw s)
 {
-	os.width(s.width);
-	return os;
+  os.width(s.width);
+  return os;
 }
 
-
-
-}
+} // namespace
+} // extern "C++"
 
 #pragma GCC visibility pop
 
diff --git a/misc/uClibc++/include/uClibc++/ios b/misc/uClibc++/include/uClibc++/ios
index 2af1a14cb..6b49921ed 100644
--- a/misc/uClibc++/include/uClibc++/ios
+++ b/misc/uClibc++/include/uClibc++/ios
@@ -1,21 +1,21 @@
-/*	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
-*/
+/*  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>
@@ -27,472 +27,583 @@
 
 #pragma GCC visibility push(default)
 
-namespace std{
-	typedef signed long int streamoff;
+extern "C++"
+{
+namespace std
+{
+  typedef signed long int streamoff;
 
-	template <class stateT> class fpos;
+  template <class stateT> class fpos;
 
-	class _UCXXEXPORT ios_base {
-	public:
-		class failure;
+  class _UCXXEXPORT ios_base
+  {
+  public:
+    class failure;
 #ifdef CONFIG_UCLIBCXX_EXCEPTION
-		class failure : public exception {
-		public:
-			explicit failure(const std::string&) { }
-			explicit failure() { }
-			virtual const char* what() const throw() {
-				return "std::ios_base failure exception";
-			}
-		};
+    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;
-		};
+    class _UCXXLOCAL Init
+    {
+    public:
+      _UCXXEXPORT Init();
+      _UCXXEXPORT ~Init();
+    private:
+      static int init_cnt;
+    };
 #endif
 
-	public:
+  public:
+
+    typedef unsigned short int fmtflags;
 
-		typedef unsigned short int fmtflags;
+    static const fmtflags skipws = 0x0001;
 
-		static const fmtflags skipws 		= 0x0001;
+    static const fmtflags left = 0x0002;
+    static const fmtflags right = 0x0004;
+    static const fmtflags internal = 0x0008;
 
-		static const fmtflags left		= 0x0002;
-		static const fmtflags right		= 0x0004;
-		static const fmtflags internal		= 0x0008;
+    static const fmtflags boolalpha = 0x0010;
 
-		static const fmtflags boolalpha		= 0x0010;
+    static const fmtflags dec = 0x0020;
+    static const fmtflags oct = 0x0040;
+    static const fmtflags hex = 0x0080;
 
-		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 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 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 adjustfield	= left | right | internal;
-		static const fmtflags basefield		= dec | oct | hex;
-		static const fmtflags floatfield	= fixed | scientific;
+    static const fmtflags unitbuf = 0x4000;
 
-		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 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 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;
 
-		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() const{
-			return mformat;
-		}
-		_UCXXEXPORT fmtflags flags(fmtflags fmtfl);
+    _UCXXEXPORT fmtflags flags(fmtflags fmtfl);
 
-		fmtflags setf(fmtflags fmtfl);
-		fmtflags setf(fmtflags fmtfl, fmtflags mask );
+    fmtflags setf(fmtflags fmtfl);
+    fmtflags setf(fmtflags fmtfl, fmtflags mask);
 
-		_UCXXEXPORT void unsetf(fmtflags mask){
-			mformat&= ~mask;
-		}
+    _UCXXEXPORT void unsetf(fmtflags mask)
+    {
+      mformat&= ~mask;
+    }
 
-		_UCXXEXPORT streamsize precision() const{
-			return mprecision;
-		}
+    _UCXXEXPORT streamsize precision() const
+    {
+      return mprecision;
+    }
 
-		_UCXXEXPORT streamsize precision(streamsize prec);
+    _UCXXEXPORT streamsize precision(streamsize prec);
 
-		_UCXXEXPORT streamsize width() const{
-			return mwidth;
-		}
+    _UCXXEXPORT streamsize width() const
+    {
+      return mwidth;
+    }
 
-		_UCXXEXPORT streamsize width(streamsize wide);
+    _UCXXEXPORT streamsize width(streamsize wide);
 
-		_UCXXEXPORT locale imbue(const locale& loc);
+    _UCXXEXPORT locale imbue(const locale& loc);
 
-		_UCXXEXPORT locale getloc() const{
-			return mLocale;
-		}
+    _UCXXEXPORT locale getloc() const
+    {
+      return mLocale;
+    }
 
-//		FIXME - These need to be implemented
-//		static int xalloc();
-//		long&  iword(int index);
-//		void*& pword(int index);
+//  FIXME - These need to be implemented
+//  static int xalloc();
+//  long&  iword(int index);
+//  void*& pword(int index);
 
-		_UCXXEXPORT ~ios_base() { }
+    _UCXXEXPORT ~ios_base() { }
 
-		enum event { erase_event, imbue_event, copyfmt_event };
+    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);
+    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; }
+    //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)
+  protected:
+    _UCXXEXPORT ios_base() : mLocale(), mformat(dec | skipws), mstate(goodbit),
+      mmode(), mdir(), mprecision(6), mwidth(0)
 #ifdef __UCLIBCXX_SUPPORT_CDIR__
-			,mInit()
+      ,mInit()
 #endif
-		{
-
-		}
-		locale mLocale;
-		fmtflags mformat;
-		iostate mstate;
-		openmode mmode;
-		seekdir mdir;
-		streamsize mprecision;
-		streamsize mwidth;
+    {
+
+    }
+    locale mLocale;
+    fmtflags mformat;
+    iostate mstate;
+    openmode mmode;
+    seekdir mdir;
+    streamsize mprecision;
+    streamsize mwidth;
 #ifdef __UCLIBCXX_SUPPORT_CDIR__
-		Init mInit;
+    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);
+  };
+
+  // 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 CONFIG_UCLIBCXX_EXCEPTION
-			if(rdstate() & throw_mask){
-				throw failure();
-			}
+      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;
-		}
-	};
+    }
+
+    _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);
+  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 <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;
-	}
+  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;
-	}
+  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);
-	}
+  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;
-	};
-
-
-}
+  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;
+  };
+
+} // namespace
+} // extern "C++"
 
 #pragma GCC visibility pop
 
diff --git a/misc/uClibc++/include/uClibc++/iosfwd b/misc/uClibc++/include/uClibc++/iosfwd
index 2c14725e3..c322b64d3 100644
--- a/misc/uClibc++/include/uClibc++/iosfwd
+++ b/misc/uClibc++/include/uClibc++/iosfwd
@@ -1,114 +1,119 @@
-/*	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
-*/
+/* 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>;
+extern "C++"
+{
+
+namespace std 
+{
+  class ios_base;
+  template<> class char_traits<char>;
 
 #ifdef __UCLIBCXX_HAS_WCHAR__
-	template<> class char_traits<wchar_t>;
+  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_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 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_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_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_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 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_filebuf;
 
-	template <class charT, class traits = char_traits<charT> > class basic_ifstream;
+  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_ofstream;
 
-	template <class charT, class traits = char_traits<charT> > class basic_fstream;
+  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_istreambuf_iterator;
 
-	template <class charT, class traits = char_traits<charT> > class basic_ostreambuf_iterator;
+  template <class charT, class traits = char_traits<charT> > class basic_ostreambuf_iterator;
 
-	typedef basic_ios<char>       ios;
+  typedef basic_ios<char>       ios;
 #ifdef __UCLIBCXX_HAS_WCHAR__
-	typedef basic_ios<wchar_t>    wios;
+  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_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_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;
+  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;
+  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;
+  
+  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;
+  typedef fpos<char_traits<wchar_t>::state_type> wstreampos;
 #endif
-}
+
+} // namespace
+} // extern "C++"
 
 #pragma GCC visibility pop
 
-#endif
+#endif // __HEADER_STD_IOSFWD
diff --git a/misc/uClibc++/include/uClibc++/iostream b/misc/uClibc++/include/uClibc++/iostream
index f93987f3b..3a2f5c09e 100644
--- a/misc/uClibc++/include/uClibc++/iostream
+++ b/misc/uClibc++/include/uClibc++/iostream
@@ -1,21 +1,21 @@
-/*	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
-*/
+/*  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>
 
@@ -31,70 +31,70 @@
 
 #pragma GCC visibility push(default)
 
-namespace std{
+extern "C++"
+{
+namespace std
+{
+
 #ifdef __UCLIBCXX_SUPPORT_CIN__
-	extern istream cin;
+  extern istream cin;
 #endif
 #ifdef __UCLIBCXX_SUPPORT_COUT__
-	extern ostream cout;
+  extern ostream cout;
 #endif
 #ifdef __UCLIBCXX_SUPPORT_CERR__
-	extern ostream cerr;
+  extern ostream cerr;
 #endif
 #ifdef __UCLIBCXX_SUPPORT_CLOG__
-	extern ostream clog;
+  extern ostream clog;
 #endif
 #ifdef __UCLIBCXX_SUPPORT_WCIN__
-	extern wistream wcin;
+  extern wistream wcin;
 #endif
 #ifdef __UCLIBCXX_SUPPORT_WCOUT__
-	extern wostream wcout;
+  extern wostream wcout;
 #endif
 #ifdef __UCLIBCXX_SUPPORT_WCERR__
-	extern wostream wcerr;
+  extern wostream wcerr;
 #endif
 #ifdef __UCLIBCXX_SUPPORT_WCLOG__
-	extern wostream 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;
-	}
-
+  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();
+  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
 
-
-
-}
+} // namespace
+} // extern "C++"
 
 #pragma GCC visibility pop
 
diff --git a/misc/uClibc++/include/uClibc++/istream b/misc/uClibc++/include/uClibc++/istream
index 37ffa127b..faedcc1c8 100644
--- a/misc/uClibc++/include/uClibc++/istream
+++ b/misc/uClibc++/include/uClibc++/istream
@@ -1,21 +1,21 @@
-/*	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.
-*/
+/*  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>
@@ -28,572 +28,704 @@
 
 #pragma GCC visibility push(default)
 
-namespace std{
-
-	typedef basic_istream<char> istream;
+extern "C++"
+{
+namespace std
+{
+  typedef basic_istream<char> istream;
 
 #ifdef __UCLIBCXX_HAS_WCHAR__
-	typedef basic_istream<wchar_t> wistream;
+  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);
+  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 CONFIG_HAVE_FLOAT
-		basic_istream<charT,traits>& operator>>(float& f);
-		basic_istream<charT,traits>& operator>>(double& f);
-		basic_istream<charT,traits>& operator>>(long double& f);
+    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;
-	}
+    _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 CONFIG_HAVE_FLOAT
-	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;
-	}
+  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;
-	}
 
+  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 & 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);
+  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 CONFIG_HAVE_FLOAT
-	template <> _UCXXEXPORT istream & istream::operator>>(float &f);
-	template <> _UCXXEXPORT istream & istream::operator>>(double &f);
-	template <> _UCXXEXPORT istream & istream::operator>>(long double &f);
+  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 istream & operator>>(istream & is, char & c);
 
-	template <> _UCXXEXPORT void __skipws(basic_istream<char,char_traits<char> >& is);
+  template <> _UCXXEXPORT void __skipws(basic_istream<char,char_traits<char> >& is);
 
 #endif
 #endif
 
-}
+} // namespace
+} // extern "C++"
 
 #pragma GCC visibility pop
 
 #endif
-
diff --git a/misc/uClibc++/include/uClibc++/istream_helpers b/misc/uClibc++/include/uClibc++/istream_helpers
index 36765dd70..b514f1a1e 100644
--- a/misc/uClibc++/include/uClibc++/istream_helpers
+++ b/misc/uClibc++/include/uClibc++/istream_helpers
@@ -1,21 +1,21 @@
-/*	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
-*/
+/*  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>
@@ -28,343 +28,452 @@
 
 #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;
-	}
+extern "C++"
+{
+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);
-
+  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) );
-				}
-			}
-		}
-	};
-
+  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 CONFIG_HAVE_FLOAT
 
-	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 CONFIG_HAVE_FLOAT
-
-	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);
-		}
-	}
-}
+  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 CONFIG_HAVE_FLOAT
+
+  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);
+    }
+  }
+
+} // namespace
+} // extern "C++"
 
 #pragma GCC visibility pop
 
diff --git a/misc/uClibc++/include/uClibc++/iterator b/misc/uClibc++/include/uClibc++/iterator
index b3d81b207..9a690d83d 100644
--- a/misc/uClibc++/include/uClibc++/iterator
+++ b/misc/uClibc++/include/uClibc++/iterator
@@ -1,21 +1,21 @@
-/*	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
-*/
+/*  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>
@@ -23,204 +23,250 @@
 #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;
-	};
-
-}
+extern "C++"
+{
+
+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;
+  };
+
+} // namespace
+} // extern "C++"
 
 #pragma GCC visibility pop
 
diff --git a/misc/uClibc++/include/uClibc++/iterator_base b/misc/uClibc++/include/uClibc++/iterator_base
index 1cae58966..307174440 100644
--- a/misc/uClibc++/include/uClibc++/iterator_base
+++ b/misc/uClibc++/include/uClibc++/iterator_base
@@ -1,21 +1,21 @@
-/*	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
-*/
+/* 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>
 
@@ -24,282 +24,320 @@
 
 #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;
-	}
+extern "C++"
+{
+
+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
 
+  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));
+  }
+
+} // namespace
+} // extern "C++"
 
+#pragma GCC visibility pop
+#endif // __STD_HEADER_ITERATOR_BASE
diff --git a/misc/uClibc++/include/uClibc++/limits b/misc/uClibc++/include/uClibc++/limits
index e275eb5ec..0b5b159e9 100644
--- a/misc/uClibc++/include/uClibc++/limits
+++ b/misc/uClibc++/include/uClibc++/limits
@@ -1,20 +1,20 @@
-/*	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
-*/
+/* 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>
 
@@ -25,638 +25,795 @@
 
 #pragma GCC visibility push(default)
 
-namespace std{
+extern "C++"
+{
+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
+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 <int bitsize> struct __bits_to_base_10
+{
+  static const int size = -1;
 };
-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<7>
+{
+  static const int size = 2;
 };
-template <> struct __bits_to_base_10<17>{
-	static const int size = 5;
+
+template <> struct __bits_to_base_10<8>
+{
+  static const int size = 2;
 };
-template <> struct __bits_to_base_10<18>{
-	static const int size = 5;
+
+template <> struct __bits_to_base_10<9>
+{
+  static const int size = 2;
 };
-template <> struct __bits_to_base_10<31>{
-	static const int size = 9;
+
+template <> struct __bits_to_base_10<10>
+{
+  static const int size = 3;
 };
-template <> struct __bits_to_base_10<32>{
-	static const int size = 9;
+
+template <> struct __bits_to_base_10<15>
+{
+  static const int size = 4;
 };
-template <> struct __bits_to_base_10<35>{
-	static const int size = 10;
+
+template <> struct __bits_to_base_10<16>
+{
+  static const int size = 4;
 };
-template <> struct __bits_to_base_10<36>{
-	static const int size = 10;
+
+template <> struct __bits_to_base_10<17>
+{
+  static const int size = 5;
 };
-template <> struct __bits_to_base_10<63>{
-	static const int size = 18;
+
+template <> struct __bits_to_base_10<18>
+{
+  static const int size = 5;
 };
-template <> struct __bits_to_base_10<64>{
-	static const int size = 19;
+
+template <> struct __bits_to_base_10<31>
+{
+  static const int size = 9;
 };
-template <> struct __bits_to_base_10<71>{
-	static const int size = 21;
+
+template <> struct __bits_to_base_10<32>
+{
+  static const int size = 9;
 };
-template <> struct __bits_to_base_10<72>{
-	static const int size = 21;
+
+template <> struct __bits_to_base_10<35>
+{
+  static const int size = 10;
 };
-template <> struct __bits_to_base_10<79>{
-	static const int size = 23;
+
+template <> struct __bits_to_base_10<36>
+{
+  static const int size = 10;
 };
-template <> struct __bits_to_base_10<80>{
-	static const int size = 24;
+
+template <> struct __bits_to_base_10<63>
+{
+  static const int size = 18;
 };
-template <> struct __bits_to_base_10<127>{
-	static const int size = 38;
+
+template <> struct __bits_to_base_10<64>
+{
+  static const int size = 19;
 };
-template <> struct __bits_to_base_10<128>{
-	static const int size = 38;
+
+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 {
+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> {
+  // 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> {
+  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> {
+  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> {
+  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> {
+  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> {
+  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> {
+  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> {
+  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> {
+  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> {
+  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> {
+  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?
-};
-
-
-
-
-
-}
+  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?
+};
+
+} // namespace
+} // extern "C++"
 
 #pragma GCC visibility pop
 
diff --git a/misc/uClibc++/include/uClibc++/list b/misc/uClibc++/include/uClibc++/list
index 2fe182c66..8daf8144d 100644
--- a/misc/uClibc++/include/uClibc++/list
+++ b/misc/uClibc++/include/uClibc++/list
@@ -1,21 +1,21 @@
-/*	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
-*/
+/*  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>
@@ -26,897 +26,1072 @@
 
 #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;
+extern "C++"
+{
+
+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;
 #ifdef CONFIG_DEBUG_LIB
-		list_start->val = 0;
+    list_start->val = 0;
 #endif
-		delete list_start;
+    delete list_start;
 #ifdef CONFIG_DEBUG_LIB
-		list_start = 0;
-		list_end = 0;
+    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;
+  }
+
+  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;
 #ifdef CONFIG_DEBUG_LIB
-			list_start->previous->val = 0;
-			list_start->previous->next = 0;
-			list_start->previous->previous = 0;
+      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;
+      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;
 #ifdef CONFIG_DEBUG_LIB
-			temp->val = 0;
-			temp->next = 0;
-			temp->previous = 0;
+      temp->val = 0;
+      temp->next = 0;
+      temp->previous = 0;
 #endif
-			delete temp;
+      delete temp;
 #ifdef CONFIG_DEBUG_LIB
-			temp = 0;
+      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;
+      --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;
 #ifdef CONFIG_DEBUG_LIB
-			temp->next = 0;
-			temp->previous = 0;
-			temp->val = 0;
+      temp->next = 0;
+      temp->previous = 0;
+      temp->val = 0;
 #endif
-			delete temp;
+      delete temp;
 #ifdef CONFIG_DEBUG_LIB
-			temp = 0;
+      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);
-	}
-
-}
+      --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);
+  }
+
+} // namespace
+} // extern "C++"
 
 #pragma GCC visibility pop
 
diff --git a/misc/uClibc++/include/uClibc++/map b/misc/uClibc++/include/uClibc++/map
index 038191af7..6816116bb 100644
--- a/misc/uClibc++/include/uClibc++/map
+++ b/misc/uClibc++/include/uClibc++/map
@@ -1,63 +1,60 @@
-/*	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
-*/
-
-
+/* 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{
-
+extern "C++"
+{
+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
 
-	//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);
-		}
-	};
+  /*  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;
-
-
+// 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.
@@ -66,199 +63,207 @@ template<class Key, class T, class Compare = less<Key>, class Allocator = alloca
  * 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>
+  : 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
+  // 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;
-	}
+  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;
+  using base::backing;
 };
 
-
-//Implementation of multimap
-
+// Implementation of multimap
 
 template<class Key, class T, class Compare, class Allocator> class _UCXXEXPORT multimap
-	: public __multi_associative<Key, pair<Key, T>, Compare, Allocator>
-
+  : 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
+  // 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;
+  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;
-
+  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.
+ * 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);
-
-}
+  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);
+
+} // namespace
+} // extern "C++"
 
 #pragma GCC visibility pop
 
 #endif
 
-	
+  
diff --git a/misc/uClibc++/include/uClibc++/memory b/misc/uClibc++/include/uClibc++/memory
index 2a7ce8c15..cd3956f18 100644
--- a/misc/uClibc++/include/uClibc++/memory
+++ b/misc/uClibc++/include/uClibc++/memory
@@ -1,21 +1,21 @@
-/*	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
-*/
+/*  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>
@@ -29,166 +29,214 @@
 
 #pragma GCC visibility push(default)
 
-namespace std{
+extern "C++"
+{
+
+namespace std
+{
 
 template <class T> class allocator;
-	// Specialize for void:
+  // Specialize for void:
 
-template <> class _UCXXEXPORT allocator<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; };
+  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{
+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; };
-
+  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>
+  : public iterator<output_iterator_tag, void, void, void, void>
 {
-		Out p;
+    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;
-	}
+  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 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> _UCXXEXPORT void return_temporary_buffer(T* p)
+{
+  free(p);
 }
 
 
-template <class T> class _UCXXEXPORT auto_ptr{
-
+template <class T> class _UCXXEXPORT auto_ptr
+{
 private:
-	T * object;
-	template <class Y> struct auto_ptr_ref{
-		Y * p;
-	};
+  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;
-	}
-	
+  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
+} // namespace std
+} // extern "C++"
 
 #pragma GCC visibility pop
 
diff --git a/misc/uClibc++/include/uClibc++/new b/misc/uClibc++/include/uClibc++/new
index 665e78395..29baba6af 100644
--- a/misc/uClibc++/include/uClibc++/new
+++ b/misc/uClibc++/include/uClibc++/new
@@ -1,21 +1,21 @@
-/*	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
-*/
+/* * 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>
@@ -26,16 +26,19 @@
 
 #pragma GCC visibility push(default)
 
-namespace std{
-	class _UCXXEXPORT bad_alloc : public exception {};
+extern "C++"
+{
 
-	struct _UCXXEXPORT nothrow_t {};
-	extern const nothrow_t nothrow;
+namespace std
+{
+  class _UCXXEXPORT bad_alloc : public exception {};
 
-	typedef void (*new_handler)();
-	_UCXXEXPORT new_handler set_new_handler(new_handler new_p) throw();
-}
+  struct _UCXXEXPORT nothrow_t {};
+  extern const nothrow_t nothrow;
 
+  typedef void (*new_handler)();
+  _UCXXEXPORT new_handler set_new_handler(new_handler new_p) throw();
+} // namespace
 
 _UCXXEXPORT void* operator new(std::size_t numBytes) throw(std::bad_alloc);
 _UCXXEXPORT void operator delete(void* ptr) throw();
@@ -51,14 +54,16 @@ _UCXXEXPORT void* operator new[](std::size_t numBytes, const std::nothrow_t& ) t
 _UCXXEXPORT void operator delete[](void* ptr, const std::nothrow_t& ) throw();
 #endif
 
-	/* Placement operators */
+/* 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
+} // extern "C++"
 
-#endif
+#pragma GCC visibility pop
 
+#endif // __STD_NEW_OPERATOR
diff --git a/misc/uClibc++/include/uClibc++/numeric b/misc/uClibc++/include/uClibc++/numeric
index 25d1b2746..880eb79f7 100644
--- a/misc/uClibc++/include/uClibc++/numeric
+++ b/misc/uClibc++/include/uClibc++/numeric
@@ -1,21 +1,21 @@
-/*	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
-*/
+/* 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>
@@ -25,135 +25,150 @@
 
 #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;
-	}
-
-}
+extern "C++"
+{
+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;
+  }
+
+} // namespace
+} // extern "C++"
 
 #pragma GCC visibility pop
 
diff --git a/misc/uClibc++/include/uClibc++/ostream b/misc/uClibc++/include/uClibc++/ostream
index 55bace3a0..c62b4c92d 100644
--- a/misc/uClibc++/include/uClibc++/ostream
+++ b/misc/uClibc++/include/uClibc++/ostream
@@ -1,20 +1,20 @@
-/*	Copyright (C) 2004-2008 Garrett A. Kajmowicz
+/*  Copyright (C) 2004-2008 Garrett A. Kajmowicz
 
-	This file is part of the uClibc++ Library.
+  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 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.
+  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
+  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>
@@ -30,479 +30,542 @@
 
 #pragma GCC visibility push(default)
 
-namespace std {
-	template <class charT, class traits > class basic_ostream;
-	typedef basic_ostream<char> ostream;
+extern "C++"
+{
+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;
+  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){
+  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*/
+      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();
+  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);
+  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){
+  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;
-		}
-	};
+      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();
+  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;
-	}
+  // 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;
-	}
+  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;
-	}
+  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;
+  }
+
+  // partial specializations
+
+  template<class traits> _UCXXEXPORT basic_ostream<char,traits>&
+    operator<<(basic_ostream<char,traits>& out, const char* 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;
-	}
+  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;
-	}
-
+  // 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);
+  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
+// 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)
+  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;
+  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)
+  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;
+  typename basic_ostream<Ch, Tr>::sentry s(os);
+  __ostream_printout<Tr, Ch, unsigned long long int>::printout(os, i);
+  return os;
 }
 
+#endif  //__STRICT_ANSI__
 
-#endif	//__STRICT_ANSI__
-
-
-
-
-}
+} // namespace
+} // extern "C++"
 
 #pragma GCC visibility pop
 
diff --git a/misc/uClibc++/include/uClibc++/ostream_helpers b/misc/uClibc++/include/uClibc++/ostream_helpers
index 6c3f9fc69..214ec259d 100644
--- a/misc/uClibc++/include/uClibc++/ostream_helpers
+++ b/misc/uClibc++/include/uClibc++/ostream_helpers
@@ -1,21 +1,21 @@
-/*	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
-*/
+/*  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>
@@ -29,459 +29,663 @@
 
 #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();
-			}
-		}
-	};
+extern "C++"
+{
+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();
-			}
-
-		}
-	};
+  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();
-			}
-		}
-	};
+  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();
-			}
-		}
-	};
+  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__
 
-}
+} // namespace
+} // extern "C++"
 
 #pragma GCC visibility pop
 
diff --git a/misc/uClibc++/include/uClibc++/queue b/misc/uClibc++/include/uClibc++/queue
index b817b1dfe..51fe35cbe 100644
--- a/misc/uClibc++/include/uClibc++/queue
+++ b/misc/uClibc++/include/uClibc++/queue
@@ -1,19 +1,20 @@
-/*      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
-*/
+/* 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>
@@ -25,102 +26,114 @@
 
 #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();
-		}
-	};
-
-}
+extern "C++"
+{
+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();
+    }
+  };
+
+} // namespace
+} // extern "C++"
 
 #pragma GCC visibility pop
 
 #endif
-
-
diff --git a/misc/uClibc++/include/uClibc++/set b/misc/uClibc++/include/uClibc++/set
index f376e4700..02f9251cc 100644
--- a/misc/uClibc++/include/uClibc++/set
+++ b/misc/uClibc++/include/uClibc++/set
@@ -1,22 +1,20 @@
-/*	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
-*/
-
-
+/* 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>
@@ -30,13 +28,14 @@
 
 #pragma GCC visibility push(default)
 
-namespace std{
-
+extern "C++"
+{
+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
@@ -44,361 +43,405 @@ template<class Key, class Compare = less<Key>, class Allocator = allocator<Key>
  * the specifications too much to be worth the risk.
  */
 
-
-//Implementation of set
-
+// Implementation of set
 
 template<class Key, class Compare, class Allocator> class _UCXXEXPORT set
-	: public __single_associative<Key, Key, Compare, Allocator>
+  : 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:
+  //Default value of allocator does not meet C++ standard specs, but it works for this library
+  //Deal with it
 
-	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;
+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
-
+// Implementation of multiset
 
 template<class Key, class Compare, class Allocator> class _UCXXEXPORT multiset
-	: public __multi_associative<Key, Key, Compare, Allocator>
+  : 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;
+  //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.
+ * 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);
-	}
-
-
-
-}
+  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);
+  }
+
+} // namespace
+} // extern "C++"
 
 #pragma GCC visibility pop
 
diff --git a/misc/uClibc++/include/uClibc++/sstream b/misc/uClibc++/include/uClibc++/sstream
index 296985374..d06d1874f 100644
--- a/misc/uClibc++/include/uClibc++/sstream
+++ b/misc/uClibc++/include/uClibc++/sstream
@@ -1,21 +1,21 @@
-/*	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
-*/
+/* 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>
 
@@ -31,345 +31,431 @@
 
 #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;
-	};
+extern "C++"
+{
+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();
+  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_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> >::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> >::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> >::
+      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 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);
+  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();
+  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__
 
@@ -378,7 +464,7 @@ namespace std{
 
 #pragma GCC visibility pop
 
-}
-
+} // namespace
+} // extern "C++"
 
 #endif
diff --git a/misc/uClibc++/include/uClibc++/stack b/misc/uClibc++/include/uClibc++/stack
index d4861b3a4..2321831ba 100644
--- a/misc/uClibc++/include/uClibc++/stack
+++ b/misc/uClibc++/include/uClibc++/stack
@@ -1,19 +1,20 @@
-/*      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
-*/
+/* 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>
@@ -23,59 +24,66 @@
 
 #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);
-	}
-
-}
+extern "C++"
+{
+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);
+  }
+
+} // namespace
+} // extern "C++"
 
 #pragma GCC visibility pop
 
diff --git a/misc/uClibc++/include/uClibc++/streambuf b/misc/uClibc++/include/uClibc++/streambuf
index 0daa388f0..2dfa213d0 100644
--- a/misc/uClibc++/include/uClibc++/streambuf
+++ b/misc/uClibc++/include/uClibc++/streambuf
@@ -1,21 +1,21 @@
-/*	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
-*/
+/*  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>
@@ -29,300 +29,379 @@
 
 #pragma GCC visibility push(default)
 
-namespace std{
-
-	template <class charT, class traits> class _UCXXEXPORT basic_streambuf{
-	public:
+extern "C++"
+{
+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;
+    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;
 
-//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)
-	{ }
+    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();
+  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);
+  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
 
-
-
-
-
-}
+} // namespace
+} // extern "C++"
 
 #pragma GCC visibility pop
 
diff --git a/misc/uClibc++/include/uClibc++/string b/misc/uClibc++/include/uClibc++/string
index f128e7e5a..47c2a9d51 100644
--- a/misc/uClibc++/include/uClibc++/string
+++ b/misc/uClibc++/include/uClibc++/string
@@ -35,6 +35,8 @@
 
 #pragma GCC visibility push(default)
 
+extern "C++"
+{
 namespace std
 {
   // Basic basic_string
@@ -1331,7 +1333,9 @@ template <> _UCXXEXPORT bool operator< (const string & lhs, const string & rhs);
 
 #endif
 #endif
+
 } // namespace
+} // extern "C++"
 
 #pragma GCC visibility pop
 
diff --git a/misc/uClibc++/include/uClibc++/string_iostream b/misc/uClibc++/include/uClibc++/string_iostream
index 4ef3b600c..46a9893c1 100644
--- a/misc/uClibc++/include/uClibc++/string_iostream
+++ b/misc/uClibc++/include/uClibc++/string_iostream
@@ -1,21 +1,21 @@
-/*	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
-*/
+/*  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>
@@ -31,114 +31,124 @@
 
 #pragma GCC visibility push(default)
 
-namespace std{
-
-
+extern "C++"
+{
+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)
+  operator<<(basic_ostream<charT, traits>& os, const basic_string<charT,traits,Allocator>& str)
 {
-	return os.write(str.data(), str.length());
+  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)
+  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();
-//	}
+  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;
+//  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)
+  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;	
+  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)
+  getline(basic_istream<charT,traits>& is, basic_string<charT,traits,Allocator>& str)
 {
-	return getline(is, str, '\n');
+  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);
+  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);
+  operator<<(basic_ostream<char, char_traits<char> >& os, 
+  const basic_string<char,char_traits<char>, std::allocator<char> >& str);
 
 #endif
 
-
 #endif
 #endif
 
-
-}
+} // namespace
+} // extern "C++"
 
 #pragma GCC visibility pop
 
diff --git a/misc/uClibc++/include/uClibc++/type_traits b/misc/uClibc++/include/uClibc++/type_traits
index fa1de40ce..2a599f78b 100644
--- a/misc/uClibc++/include/uClibc++/type_traits
+++ b/misc/uClibc++/include/uClibc++/type_traits
@@ -1,20 +1,20 @@
-/*	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
-*/
+/*  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>
@@ -27,64 +27,75 @@
 
 #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;
-	};
-
-
-
-}
+extern "C++"
+{
+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;
+  };
+
+} // namespace
+} // extern "C++"
 
 #pragma GCC visibility pop
 
diff --git a/misc/uClibc++/include/uClibc++/utility b/misc/uClibc++/include/uClibc++/utility
index b65467924..f5cb59f2f 100644
--- a/misc/uClibc++/include/uClibc++/utility
+++ b/misc/uClibc++/include/uClibc++/utility
@@ -1,88 +1,107 @@
-/*	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
-
-*/
-
+/* 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);
-	}
-
-
-}
+extern "C++"
+{
+
+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);
+    }
+  } // namespace
+
+  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);
+  }
+
+} // namespace
+} // extern "C++"
 
 #pragma GCC visibility pop
 
-#endif	//__STD_HEADER_UTILITY
+#endif  //__STD_HEADER_UTILITY
diff --git a/misc/uClibc++/include/uClibc++/valarray b/misc/uClibc++/include/uClibc++/valarray
index 09d929c49..f28ad5874 100644
--- a/misc/uClibc++/include/uClibc++/valarray
+++ b/misc/uClibc++/include/uClibc++/valarray
@@ -1,21 +1,21 @@
-/*	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
-*/
+/* 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>
 
@@ -27,1015 +27,1550 @@
 
 #pragma GCC visibility push(default)
 
-namespace std{
-
-	template<class T> class valarray;
-	class slice;
-	template<class T> class slice_array;
-	class gslice;
-	template<class T> class gslice_array;
-	template<class T> class mask_array;
-	template<class T> class indirect_array;
-
-	//Actual class definitions
-
-
-	class _UCXXEXPORT slice {
-	protected:
-		size_t sta;
-		size_t siz;
-		size_t str;
-
-	public:
-		slice() : sta(0), siz(0), str(0){  }
-		slice(size_t a, size_t b, size_t c) : sta(a), siz(b), str(c) {  }
-		slice(const slice& s) : sta(s.sta), siz(s.siz), str(s.str) {  }
-		~slice() {  }
-		size_t start() const{
-			return sta;
-		}
-		size_t size() const{
-			return siz;
-		}
-		size_t stride() const{
-			return str;
-		}
-	};
-
-
-
-	template<class T> class _UCXXEXPORT valarray {
-		friend class slice_array<T>;
-	protected:
-		T * data;
-		size_t length;
-
-	public:
-		typedef T value_type;
-
-		valarray() : data(0), length(0) {  }
-
-		explicit valarray(size_t t) : data(0), length(t){
-			data = new T[length];
-		}
-
-		valarray(const T& v, size_t t) : data(0), length(t){
-			data = new T[length];
-			for(size_t i = 0; i < length; ++i){
-				data[i] = v;
-			}
-		}
-		valarray(const T* p, size_t t) : data(0), length(t) {
-			data = new T[length];
-			for(size_t i = 0; i < length; ++i){
-				data[i] = p[i];
-			}
-		}
-		valarray(const valarray& v) : data(0), length(v.length){
-			data = new T[length];
-			for(size_t i = 0; i < length; ++i){
-				data[i] = v.data[i];
-			}
-		}
-		valarray(const slice_array<T> & sa) : data(0), length(sa.s.size()){
-			data = new T[length];
-			for(unsigned int i = 0; i < length; ++i){
-				data[i] = sa.array->data[sa.s.start() + i * sa.s.stride()];
-			}
-		}
-		valarray(const gslice_array<T>&);
-		valarray(const mask_array<T>&);
-		valarray(const indirect_array<T>&);
-		~valarray(){
-			delete [] data;
-			data = 0;
-			length = 0;
-		}
-
-		valarray<T>& operator=(const valarray<T>& v){
-			if (length != v.length) { // DR 630
-				delete [] data;
-				length = v.length;
-				data = new T[length];
-			}
-			for (size_t i = 0; i < length; ++i) {
-				data[i] = v.data[i];
-			}
-			return *this;
-		}
-		valarray<T>& operator=(const T& t){
-			for(size_t i = 0; i < length; ++i){
-				data[i] = t;
-			}
-			return *this;
-		}
-		valarray<T>& operator=(const slice_array<T>& sa){
-			for(size_t i =0; i < length; ++i){
-				data[i] = sa.data[sa.s.start() + i * sa.s.stride()];
-			}
-			return *this;
-		}
-		valarray<T>& operator=(const gslice_array<T>&);
-		valarray<T>& operator=(const mask_array<T>&);
-		valarray<T>& operator=(const indirect_array<T>&);
-
-		const T& operator[](size_t t) const{
-			return data[t];
-		}
-		T& operator[](size_t t){
-			return data[t];
-		}
-
-		valarray<T> operator[](slice s) const{
-			valarray<T> retval(s.size());
-			for(unsigned int i = 0; i< s.size(); ++i){
-				retval.data[i] = data[s.start() + i * s.stride()];
-			}
-			return retval;
-		}
-
-		slice_array<T> operator[](slice sl){
-			slice_array<T> retval;
-			retval.s = sl;
-			retval.array = this;
-			return retval;
-		}
-
-		valarray<T> operator[](const gslice&) const;
-		gslice_array<T> operator[](const gslice&);
-		valarray<T> operator[](const valarray<bool>&) const;
-		mask_array<T> operator[](const valarray<bool>&);
-		valarray<T> operator[](const valarray<size_t>&) const;
-		indirect_array<T> operator[](const valarray<size_t>&);
-
-		valarray<T> operator+() const{
-			valarray<T> retval(length);
-			for(size_t i = 0; i< length ; ++i){
-				retval.data[i] = +data[i];
-			}
-			return retval;
-		}
-		valarray<T> operator-() const{
-			valarray<T> retval(length);
-			for(size_t i = 0; i< length; ++i){
-				retval.data[i] = -data[i];
-			}
-			return retval;
-		}
-		valarray<T> operator~() const{
-			valarray<T> retval(length);
-			for(size_t i = 0; i< length ; ++i){
-				retval.data[i] = ~data[i];
-			}
-			return retval;
-		}
-		valarray<bool> operator!() const{
-			valarray<bool> retval(length);
-			for (size_t i = 0; i < length ; ++i){
-				retval[i] = !data[i];
-			}
-			return retval;
-		}
-		valarray<T>& operator*= (const T& t){
-			for(size_t i=0;i<length;++i){
-				data[i] *= t;
-			}
-			return *this;
-		}
-		valarray<T>& operator/= (const T& t){
-			for(size_t i=0;i<length;++i){
-				data[i] /= t;
-			}
-			return *this;
-		}
-		valarray<T>& operator%= (const T& t){
-			for(size_t i=0;i<length;++i){
-				data[i] %= t;
-			}
-			return *this;
-		}
-		valarray<T>& operator+= (const T& t){
-			for(size_t i=0;i<length;++i){
-				data[i] += t;
-			}
-			return *this;
-		}
-		valarray<T>& operator-= (const T& t){
-			for(size_t i=0;i<length;++i){
-				data[i] -= t;
-			}
-			return *this;
-		}
-		valarray<T>& operator^= (const T& t){
-			for(size_t i=0;i<length;++i){
-				data[i] ^= t;
-			}
-			return *this;
-		}
-		valarray<T>& operator&= (const T& t){
-			for(size_t i=0;i<length;++i){
-				data[i] &= t;
-			}
-			return *this;
-		}
-		valarray<T>& operator|= (const T& t){
-			for(size_t i=0;i<length; ++i){
-				data[i] |= t;
-			}
-			return *this;
-		}
-		valarray<T>& operator<<=(const T& t){
-			for(size_t i=0;i<length;++i){
-				data[i] <<= t;
-			}
-			return *this;
-		}
-		valarray<T>& operator>>=(const T& t){
-			for(size_t i=0;i<length;++i){
-				data[i] >>= t;
-			}
-			return *this;
-		}
-		valarray<T>& operator*= (const valarray<T>& a){
-			for(size_t i=0;i<length;++i){
-				data[i] *= a.data[i];
-			}
-			return *this;
-		}
-		valarray<T>& operator/= (const valarray<T>& a){
-			for(size_t i=0;i<length;++i){
-				data[i] /= a.data[i];
-			}
-			return *this;
-		}
-		valarray<T>& operator%= (const valarray<T>& a){
-			for(size_t i=0;i<length;++i){
-				data[i] %= a.data[i];
-			}
-			return *this;
-		}
-		valarray<T>& operator+= (const valarray<T>& a){
-			for(size_t i=0;i<length;++i){
-				data[i] += a.data[i];
-			}
-			return *this;
-		}
-		valarray<T>& operator-= (const valarray<T>& a){
-			for(size_t i=0;i<length ;++i){
-				data[i] -= a.data[i];
-			}
-			return *this;
-		}
-		valarray<T>& operator^= (const valarray<T>& a){
-			for(size_t i=0;i<length;++i){
-				data[i] ^= a.data[i];
-			}
-			return *this;
-		}
-		valarray<T>& operator|= (const valarray<T>& a){
-			for(size_t i=0;i<length ;++i){
-				data[i] |= a.data[i];
-			}
-			return *this;
-		}
-		valarray<T>& operator&= (const valarray<T>& a){
-			for(size_t i=0;i<length;++i){
-				data[i] &= a.data[i];
-			}
-			return *this;
-		}
-		valarray<T>& operator<<=(const valarray<T>& a){
-			for(size_t i=0;i<length;++i){
-				data[i] <<= a.data[i];
-			}
-			return *this;
-		}
-		valarray<T>& operator>>=(const valarray<T>& a){
-			for(size_t i=0;i<length;++i){
-				data[i] >>= a.data[i];
-			}
-			return *this;
-		}
+extern "C++"
+{
+namespace std
+{
+  template<class T> class valarray;
+  class slice;
+  template<class T> class slice_array;
+  class gslice;
+  template<class T> class gslice_array;
+  template<class T> class mask_array;
+  template<class T> class indirect_array;
+
+  // Actual class definitions
+
+  class _UCXXEXPORT slice{
+  protected:
+    size_t sta;
+    size_t siz;
+    size_t str;
+
+  public:
+    slice() : sta(0), siz(0), str(0){  }
+    slice(size_t a, size_t b, size_t c) : sta(a), siz(b), str(c) {  }
+    slice(const slice& s) : sta(s.sta), siz(s.siz), str(s.str) {  }
+    ~slice() {  }
+
+    size_t start() const
+    {
+      return sta;
+    }
+
+    size_t size() const
+    {
+      return siz;
+    }
+
+    size_t stride() const
+    {
+      return str;
+    }
+  };
+
+  template<class T> class _UCXXEXPORT valarray
+  {
+    friend class slice_array<T>;
+  protected:
+    T * data;
+    size_t length;
+
+  public:
+    typedef T value_type;
+
+    valarray() : data(0), length(0) {  }
+
+    explicit valarray(size_t t) : data(0), length(t)
+    {
+      data = new T[length];
+    }
+
+    valarray(const T& v, size_t t) : data(0), length(t)
+    {
+      data = new T[length];
+      for (size_t i = 0; i < length; ++i)
+      {
+        data[i] = v;
+      }
+    }
+
+    valarray(const T* p, size_t t) : data(0), length(t)
+    {
+      data = new T[length];
+      for (size_t i = 0; i < length; ++i){
+        data[i] = p[i];
+      }
+    }
+
+    valarray(const valarray& v) : data(0), length(v.length)
+    {
+      data = new T[length];
+      for (size_t i = 0; i < length; ++i)
+      {
+        data[i] = v.data[i];
+      }
+    }
+
+    valarray(const slice_array<T> & sa) : data(0), length(sa.s.size())
+    {
+      data = new T[length];
+      for (unsigned int i = 0; i < length; ++i)
+      {
+        data[i] = sa.array->data[sa.s.start() + i * sa.s.stride()];
+      }
+    }
+
+    valarray(const gslice_array<T>&);
+    valarray(const mask_array<T>&);
+    valarray(const indirect_array<T>&);
+
+    ~valarray()
+    {
+      delete [] data;
+      data = 0;
+      length = 0;
+    }
+
+    valarray<T>& operator=(const valarray<T>& v)
+    {
+      if (length != v.length)
+      {
+        // DR 630
+
+        delete [] data;
+        length = v.length;
+        data = new T[length];
+      }
+
+      for (size_t i = 0; i < length; ++i)
+      {
+        data[i] = v.data[i];
+      }
+
+      return *this;
+    }
+
+    valarray<T>& operator=(const T& t)
+    {
+      for (size_t i = 0; i < length; ++i)
+      {
+        data[i] = t;
+      }
+
+      return *this;
+    }
+
+    valarray<T>& operator=(const slice_array<T>& sa)
+    {
+      for (size_t i =0; i < length; ++i)
+      {
+        data[i] = sa.data[sa.s.start() + i * sa.s.stride()];
+      }
+
+      return *this;
+    }
+
+    valarray<T>& operator=(const gslice_array<T>&);
+    valarray<T>& operator=(const mask_array<T>&);
+    valarray<T>& operator=(const indirect_array<T>&);
+
+    const T& operator[](size_t t) const
+    {
+      return data[t];
+    }
+
+    T& operator[](size_t t)
+    {
+      return data[t];
+    }
+
+    valarray<T> operator[](slice s) const
+    {
+      valarray<T> retval(s.size());
+      for (unsigned int i = 0; i< s.size(); ++i)
+      {
+        retval.data[i] = data[s.start() + i * s.stride()];
+      }
+
+      return retval;
+    }
+
+    slice_array<T> operator[](slice sl)
+    {
+      slice_array<T> retval;
+      retval.s = sl;
+      retval.array = this;
+      return retval;
+    }
+
+    valarray<T> operator[](const gslice&) const;
+    gslice_array<T> operator[](const gslice&);
+    valarray<T> operator[](const valarray<bool>&) const;
+    mask_array<T> operator[](const valarray<bool>&);
+    valarray<T> operator[](const valarray<size_t>&) const;
+    indirect_array<T> operator[](const valarray<size_t>&);
+
+    valarray<T> operator+() const
+    {
+      valarray<T> retval(length);
+      for (size_t i = 0; i< length ; ++i)
+      {
+        retval.data[i] = +data[i];
+      }
+
+      return retval;
+    }
+
+    valarray<T> operator-() const
+    {
+      valarray<T> retval(length);
+      for (size_t i = 0; i< length; ++i)
+      {
+        retval.data[i] = -data[i];
+      }
+
+      return retval;
+    }
+
+    valarray<T> operator~() const
+    {
+      valarray<T> retval(length);
+      for (size_t i = 0; i< length ; ++i)
+      {
+        retval.data[i] = ~data[i];
+      }
+
+      return retval;
+    }
+
+    valarray<bool> operator!() const
+    {
+      valarray<bool> retval(length);
+      for (size_t i = 0; i < length ; ++i)
+      {
+        retval[i] = !data[i];
+      }
+
+      return retval;
+    }
+
+    valarray<T>& operator*= (const T& t)
+    {
+      for (size_t i=0;i<length;++i)
+      {
+        data[i] *= t;
+      }
+
+      return *this;
+    }
+
+    valarray<T>& operator/= (const T& t)
+    {
+      for (size_t i=0; i<length; ++i)
+      {
+        data[i] /= t;
+      }
+
+      return *this;
+    }
+
+    valarray<T>& operator%= (const T& t)
+    {
+      for (size_t i=0; i<length; ++i)
+      {
+        data[i] %= t;
+      }
+
+      return *this;
+    }
+
+    valarray<T>& operator+= (const T& t
+    ){
+      for (size_t i=0; i<length; ++i)
+      {
+        data[i] += t;
+      }
+
+      return *this;
+    }
+
+    valarray<T>& operator-= (const T& t)
+    {
+      for (size_t i=0; i<length; ++i)
+      {
+        data[i] -= t;
+      }
+
+      return *this;
+    }
+
+    valarray<T>& operator^= (const T& t)
+    {
+      for (size_t i=0; i<length; ++i)
+      {
+        data[i] ^= t;
+      }
+
+      return *this;
+    }
+
+    valarray<T>& operator&= (const T& t)
+    {
+      for (size_t i=0; i<length ;++i)
+      {
+        data[i] &= t;
+      }
+
+      return *this;
+    }
+
+    valarray<T>& operator|= (const T& t)
+    {
+      for (size_t i=0; i<length; ++i)
+      {
+        data[i] |= t;
+      }
+
+      return *this;
+    }
+
+    valarray<T>& operator<<=(const T& t)
+    {
+      for (size_t i=0; i<length; ++i)
+      {
+        data[i] <<= t;
+      }
+
+      return *this;
+    }
+
+    valarray<T>& operator>>=(const T& t)
+    {
+      for (size_t i=0; i<length; ++i)
+      {
+        data[i] >>= t;
+      }
+
+      return *this;
+    }
+
+    valarray<T>& operator*= (const valarray<T>& a)
+    {
+      for (size_t i=0; i<length; ++i)
+      {
+        data[i] *= a.data[i];
+      }
+
+      return *this;
+    }
+
+    valarray<T>& operator/= (const valarray<T>& a)
+    {
+      for (size_t i=0; i<length; ++i)
+      {
+        data[i] /= a.data[i];
+      }
+
+      return *this;
+    }
+
+    valarray<T>& operator%= (const valarray<T>& a)
+    {
+      for (size_t i=0; i<length; ++i)
+      {
+        data[i] %= a.data[i];
+      }
+
+      return *this;
+    }
+
+    valarray<T>& operator+= (const valarray<T>& a)
+    {
+      for (size_t i=0; i<length; ++i)
+      {
+        data[i] += a.data[i];
+      }
+
+      return *this;
+    }
+
+    valarray<T>& operator-= (const valarray<T>& a)
+    {
+      for (size_t i=0; i<length; ++i)
+      {
+        data[i] -= a.data[i];
+      }
+
+      return *this;
+    }
+
+    valarray<T>& operator^= (const valarray<T>& a)
+    {
+      for (size_t i=0; i<length; ++i)
+      {
+        data[i] ^= a.data[i];
+      }
+
+      return *this;
+    }
+
+    valarray<T>& operator|= (const valarray<T>& a)
+    {
+      for (size_t i=0; i<length; ++i)
+      {
+        data[i] |= a.data[i];
+      }
+
+      return *this;
+    }
+
+    valarray<T>& operator&= (const valarray<T>& a)
+    {
+      for (size_t i=0; i<length; ++i)
+      {
+        data[i] &= a.data[i];
+      }
+
+      return *this;
+    }
+
+    valarray<T>& operator<<=(const valarray<T>& a)
+    {
+      for (size_t i=0; i<length; ++i)
+      {
+        data[i] <<= a.data[i];
+      }
+
+      return *this;
+    }
+
+    valarray<T>& operator>>=(const valarray<T>& a)
+    {
+      for (size_t i=0; i<length; ++i)
+      {
+        data[i] >>= a.data[i];
+      }
+
+      return *this;
+    }
+
 #if 0
-		void swap(valarray& other) noexcept {
-			std::swap(length, other.length);
-			std::swap(data, other.data);
-		}
+    void swap(valarray& other) noexcept
+    {
+      std::swap(length, other.length);
+      std::swap(data, other.data);
+    }
 #endif
-		size_t size() const{
-			return length;
-		}
-
-		T sum() const{
-			T retval(data[0]);
-			for(size_t i = 1; i< length; ++i){
-				retval += data[i];
-			}
-			return retval;
-		}
-
-		T min() const{
-			T retval(data[0]);
-			for(size_t i = 1; i< length; ++i){
-				if(data[i] < retval){
-					retval = data[i];
-				}
-			}
-			return retval;
-		}
-
-		T max() const{
-			T retval(data[0]);
-			for(size_t i = 1; i< length; ++i){
-				if(retval < data[i]){
-					retval = data[i];
-				}
-			}
-			return retval;
-		}
-
-		valarray<T> shift (int n) const{
-			valarray<T> retval(length);
-			if (n < 0) {
-				if (-size_t(n) > length)
-					n = -int(length);
-			} else {
-				if (size_t(n) > length)
-					n = int(length);
-			}
-			for (size_t i = 0; i < length ; ++i) {
-				if ((n + i) < length)
-					retval.data[i] = data[n + i];
-			}
-			return retval;
-		}
-		valarray<T> cshift(int n) const{
-			valarray<T> retval(length);
-			if (length == 0)
-				return retval;
-			if (n < 0) {
-				if (-size_t(n) > length)
-					n = -int(-size_t(n) % length);
-				n = length + n;
-			} else {
-				if (size_t(n) > length)
-					n = int(size_t(n) % length);
-			}
-			for (size_t i = 0; i < length ; ++i){
-				retval.data[i] = data[(n + i) % length];
-			}
-			return retval;
-		}
-		valarray<T> apply(T func(T) ) const{
-			valarray<T> retval(length);
-			for(size_t i = 0; i< length; ++i){
-				retval.data[i] = func(data[i]);
-			}
-			return retval;
-		}
-		valarray<T> apply(T func(const T&)) const{
-			valarray<T> retval(length);
-			for(size_t i = 0; i< length; ++i){
-				retval.data[i] = func(data[i]);
-			}
-			return retval;
-		}
-		void resize(size_t sz, T c = T()){
-			delete [] data;
-			data = 0;
-			if(sz > 0){
-				data = new T[sz];
-				for(size_t i = 0; i < sz; ++i){
-					data[i] = c;
-				}
-			}
-			length = sz;
-		}
-	};
-
-
-
-	template <class T> class _UCXXEXPORT slice_array {
-		friend class valarray<T>;
-	public:
-		typedef T value_type;
-
-		void operator=  (const valarray<T>& v) const{
-			for(unsigned int i = 0; i < s.size(); ++i){
-				array->data[s.start() + i * s.stride()] = v[i];
-			}
-		}
-		void operator=  (const T & v){
-			for(unsigned int i = 0; i < s.size(); ++i){
-				array->data[s.start() + i * s.stride()] = v;
-			}
-		}
-		void fill(const T & v){
-			for(unsigned int i = 0; i < s.size(); ++i){
-				array->data[s.start() + i * s.stride()] = v;
-			}
-		}
-		void operator*= (const valarray<T>& v) const{
-			for(unsigned int i = 0; i < s.size(); ++i){
-				array->data[s.start() + i * s.stride()] *= v[i];
-			}
-		}
-		void operator/= (const valarray<T>& v) const{
-			for(unsigned int i = 0; i < s.size(); ++i){
-				array->data[s.start() + i * s.stride()] /= v[i];
-			}
-		}
-		void operator%= (const valarray<T>& v) const{
-			for(unsigned int i = 0; i < s.size(); ++i){
-				array->data[s.start() + i * s.stride()] %= v[i];
-			}
-		}
-		void operator+= (const valarray<T>& v) const{
-			for(unsigned int i = 0; i < s.size(); ++i){
-				array->data[s.start() + i * s.stride()] += v[i];
-			}
-		}
-		void operator-= (const valarray<T>& v) const{
-			for(unsigned int i = 0; i < s.size(); ++i){
-				array->data[s.start() + i * s.stride()] -= v[i];
-			}
-		}
-		void operator^= (const valarray<T>& v) const{
-			for(unsigned int i = 0; i < s.size(); ++i){
-				array->data[s.start() + i * s.stride()] ^= v[i];
-			}
-		}
-		void operator&= (const valarray<T>& v) const{
-			for(unsigned int i = 0; i < s.size(); ++i){
-				array->data[s.start() + i * s.stride()] &= v[i];
-			}
-		}
-		void operator|= (const valarray<T>& v) const{
-			for(unsigned int i = 0; i < s.size(); ++i){
-				array->data[s.start() + i * s.stride()] |= v[i];
-			}
-		}
-		void operator<<=(const valarray<T>& v) const{
-			for(unsigned int i = 0; i < s.size(); ++i){
-				array->data[s.start() + i * s.stride()] <<= v[i];
-			}
-		}
-		void operator>>=(const valarray<T>& v) const{
-			for(unsigned int i = 0; i < s.size(); ++i){
-				array->data[s.start() + i * s.stride()] >>= v[i];
-			}
-		}
-		~slice_array(){
-			array = 0;
-		}
-
-	private:
-		slice_array() : array(0){  }
-
-	public:
-		slice_array(const slice_array& sa) : array(sa.array), s(sa.s){  }
-		slice_array& operator=(const slice_array& sa){
-			array = sa.array;
-			s = sa.s;
-			return *this;
-		}
-
-	private:
-		valarray<T> * array;
-		slice s;
-	};
-
-
-	class _UCXXEXPORT gslice {
-	private:
-		size_t sta;
-		valarray<size_t> siz;
-		valarray<size_t> str;
-
-	public:
-		gslice() : sta(0), siz(), str() { } // DR 543
-		gslice(size_t s, const valarray<size_t>& l, const valarray<size_t>& d)
-			: sta(s), siz(l), str(d) {  }
-
-		size_t start() const{
-			return sta;
-		}
-		valarray<size_t> size() const{
-			return siz;
-		}
-		valarray<size_t> stride() const{
-			return str;
-		}
-	};
-
-	template <class T> class gslice_array {
-	private:
-		friend class valarray<T>;
-
-	public:
-		~gslice_array();
-
-		void operator=(const valarray<T>& array) const;
-		void operator*=(const valarray<T>& array) const;
-		void operator/=(const valarray<T>& array) const;
-		void operator%=(const valarray<T>& array) const;
-		void operator+=(const valarray<T>& array) const;
-		void operator-=(const valarray<T>& array) const;
-		void operator^=(const valarray<T>& array) const;
-		void operator&=(const valarray<T>& array) const;
-		void operator|=(const valarray<T>& array) const;
-		void operator<<=(const valarray<T>& array) const;
-		void operator>>=(const valarray<T>& array) const;
+
+    size_t size() const
+    {
+      return length;
+    }
+
+    T sum() const
+    {
+      T retval(data[0]);
+
+      for (size_t i = 1; i< length; ++i)
+      {
+        retval += data[i];
+      }
+
+      return retval;
+    }
+
+    T min() const
+    {
+      T retval(data[0]);
+
+      for (size_t i = 1; i< length; ++i)
+      {
+        if (data[i] < retval)
+        {
+          retval = data[i];
+        }
+      }
+
+      return retval;
+    }
+
+    T max() const
+    {
+      T retval(data[0]);
+
+      for (size_t i = 1; i< length; ++i)
+      {
+        if (retval < data[i])
+        {
+          retval = data[i];
+        }
+      }
+
+      return retval;
+    }
+
+    valarray<T> shift (int n) const
+    {
+      valarray<T> retval(length);
+
+      if (n < 0)
+      {
+        if (-size_t(n) > length)
+        {
+          n = -int(length);
+        }
+      }
+      else
+      {
+        if (size_t(n) > length)
+        {
+          n = int(length);
+        }
+      }
+
+      for (size_t i = 0; i < length ; ++i)
+      {
+        if ((n + i) < length)
+        {
+          retval.data[i] = data[n + i];
+        }
+      }
+
+      return retval;
+    }
+
+    valarray<T> cshift(int n) const
+    {
+      valarray<T> retval(length);
+
+      if (length == 0)
+      {
+        return retval;
+      }
+
+      if (n < 0)
+      {
+        if (-size_t(n) > length)
+        {
+          n = -int(-size_t(n) % length);
+        }
+
+        n = length + n;
+      }
+      else
+      {
+        if (size_t(n) > length)
+        {
+          n = int(size_t(n) % length);
+        }
+      }
+
+      for (size_t i = 0; i < length ; ++i)
+      {
+        retval.data[i] = data[(n + i) % length];
+      }
+
+      return retval;
+    }
+
+    valarray<T> apply(T func(T)) const
+    {
+      valarray<T> retval(length);
+
+      for (size_t i = 0; i< length; ++i)
+      {
+        retval.data[i] = func(data[i]);
+      }
+
+      return retval;
+    }
+
+    valarray<T> apply(T func(const T&)) const
+    {
+      valarray<T> retval(length);
+
+      for (size_t i = 0; i< length; ++i)
+      {
+        retval.data[i] = func(data[i]);
+      }
+
+      return retval;
+    }
+
+    void resize(size_t sz, T c = T())
+    {
+      delete [] data;
+
+      data = 0;
+      if (sz > 0)
+      {
+        data = new T[sz];
+
+        for (size_t i = 0; i < sz; ++i)
+        {
+          data[i] = c;
+        }
+      }
+
+      length = sz;
+    }
+  };
+
+  template <class T> class _UCXXEXPORT slice_array
+  {
+    friend class valarray<T>;
+  public:
+    typedef T value_type;
+
+    void operator=  (const valarray<T>& v) const
+    {
+      for (unsigned int i = 0; i < s.size(); ++i)
+      {
+        array->data[s.start() + i * s.stride()] = v[i];
+      }
+    }
+
+    void operator=  (const T & v)
+    {
+      for (unsigned int i = 0; i < s.size(); ++i)
+      {
+        array->data[s.start() + i * s.stride()] = v;
+      }
+    }
+
+    void fill(const T & v)
+    {
+      for (unsigned int i = 0; i < s.size(); ++i)
+      {
+        array->data[s.start() + i * s.stride()] = v;
+      }
+    }
+
+    void operator*= (const valarray<T>& v) const
+    {
+      for (unsigned int i = 0; i < s.size(); ++i)
+      {
+        array->data[s.start() + i * s.stride()] *= v[i];
+      }
+    }
+
+    void operator/= (const valarray<T>& v) const
+    {
+      for (unsigned int i = 0; i < s.size(); ++i)
+      {
+        array->data[s.start() + i * s.stride()] /= v[i];
+      }
+    }
+
+    void operator%= (const valarray<T>& v) const
+    {
+      for (unsigned int i = 0; i < s.size(); ++i)
+      {
+        array->data[s.start() + i * s.stride()] %= v[i];
+      }
+    }
+
+    void operator+= (const valarray<T>& v) const
+    {
+      for (unsigned int i = 0; i < s.size(); ++i)
+      {
+        array->data[s.start() + i * s.stride()] += v[i];
+      }
+    }
+
+    void operator-= (const valarray<T>& v) const
+    {
+      for (unsigned int i = 0; i < s.size(); ++i)
+      {
+        array->data[s.start() + i * s.stride()] -= v[i];
+      }
+    }
+
+    void operator^= (const valarray<T>& v) const
+    {
+      for (unsigned int i = 0; i < s.size(); ++i)
+      {
+        array->data[s.start() + i * s.stride()] ^= v[i];
+      }
+    }
+
+    void operator&= (const valarray<T>& v) const
+    {
+      for (unsigned int i = 0; i < s.size(); ++i)
+      {
+        array->data[s.start() + i * s.stride()] &= v[i];
+      }
+    }
+
+    void operator|= (const valarray<T>& v) const
+    {
+      for (unsigned int i = 0; i < s.size(); ++i)
+      {
+        array->data[s.start() + i * s.stride()] |= v[i];
+      }
+    }
+
+    void operator<<=(const valarray<T>& v) const
+    {
+      for (unsigned int i = 0; i < s.size(); ++i)
+      {
+        array->data[s.start() + i * s.stride()] <<= v[i];
+      }
+    }
+
+    void operator>>=(const valarray<T>& v) const
+    {
+      for (unsigned int i = 0; i < s.size(); ++i)
+      {
+        array->data[s.start() + i * s.stride()] >>= v[i];
+      }
+    }
+
+    ~slice_array()
+    {
+      array = 0;
+    }
+
+  private:
+    slice_array() : array(0){  }
+
+  public:
+    slice_array(const slice_array& sa) : array(sa.array), s(sa.s){  }
+
+    slice_array& operator=(const slice_array& sa)
+    {
+      array = sa.array;
+      s = sa.s;
+      return *this;
+    }
+
+  private:
+    valarray<T> * array;
+    slice s;
+  };
+
+  class _UCXXEXPORT gslice
+  {
+  private:
+    size_t sta;
+    valarray<size_t> siz;
+    valarray<size_t> str;
+
+  public:
+    gslice() : sta(0), siz(), str() { } // DR 543
+    gslice(size_t s, const valarray<size_t>& l, const valarray<size_t>& d)
+      : sta(s), siz(l), str(d) {  }
+
+    size_t start() const
+    {
+      return sta;
+    }
+
+    valarray<size_t> size() const
+    {
+      return siz;
+    }
+
+    valarray<size_t> stride() const
+    {
+      return str;
+    }
+  };
+
+  template <class T> class gslice_array
+  {
+  private:
+    friend class valarray<T>;
+
+  public:
+    ~gslice_array();
+
+    void operator=(const valarray<T>& array) const;
+    void operator*=(const valarray<T>& array) const;
+    void operator/=(const valarray<T>& array) const;
+    void operator%=(const valarray<T>& array) const;
+    void operator+=(const valarray<T>& array) const;
+    void operator-=(const valarray<T>& array) const;
+    void operator^=(const valarray<T>& array) const;
+    void operator&=(const valarray<T>& array) const;
+    void operator|=(const valarray<T>& array) const;
+    void operator<<=(const valarray<T>& array) const;
+    void operator>>=(const valarray<T>& array) const;
  
-		void operator=(const T&);  
-
-	private:
-		gslice_array();
-		gslice_array(const gslice_array<T>&);
-    		gslice_array<T>& operator= (const gslice_array<T>& array);
-	};
-
-
-
-	template<class T> valarray<T> operator* (const valarray<T>& lhs, const valarray<T>& rhs){
-		valarray<T> retval(lhs);
-		retval *= rhs;
-		return retval;
-	}
-
-	template<class T> valarray<T> operator* (const valarray<T>& lhs, const T& rhs){
-		valarray<T> retval(lhs);
-		retval *= rhs;
-		return retval;
-	}
-	template<class T> valarray<T> operator* (const T& lhs, const valarray<T>& rhs){
-		valarray<T> retval(rhs);
-		retval *= lhs;
-		return retval;
-	}
-	template<class T> valarray<T> operator/ (const valarray<T>& lhs, const valarray<T>& rhs){
-		valarray<T> retval(lhs);
-		retval /= rhs;
-		return retval;
-	}
-	template<class T> valarray<T> operator/ (const valarray<T>& lhs, const T& rhs){
-		valarray<T> retval(lhs);
-		retval /= rhs;
-		return retval;
-	}
-	template<class T> valarray<T> operator/ (const T& lhs, const valarray<T>& rhs){
-		valarray<T> retval(lhs, rhs.size());
-		retval /= rhs;
-		return retval;
-	}
-	template<class T> valarray<T> operator% (const valarray<T>& lhs, const valarray<T>& rhs){
-		valarray<T> retval(lhs);
-		retval %= rhs;
-		return retval;
-	}
-	template<class T> valarray<T> operator% (const valarray<T>& lhs, const T& rhs){
-		valarray<T> retval(lhs);
-		retval %= rhs;
-		return retval;
-	}
-	template<class T> valarray<T> operator% (const T& lhs, const valarray<T>& rhs){
-		valarray<T> retval(lhs, rhs.size());
-		retval %= rhs;
-		return retval;
-	}
-	template<class T> valarray<T> operator+ (const valarray<T>& lhs, const valarray<T>& rhs){
-		valarray<T> retval(lhs);
-		retval += rhs;
-		return retval;
-	}
-	template<class T> valarray<T> operator+ (const valarray<T>& lhs, const T& rhs){
-		valarray<T> retval(lhs);
-		retval += rhs;
-		return retval;
-	}
-	template<class T> valarray<T> operator+ (const T& lhs, const valarray<T>& rhs){
-		valarray<T> retval(lhs, rhs.size());
-		retval += rhs;
-		return retval;
-	}
-	template<class T> valarray<T> operator- (const valarray<T>& lhs, const valarray<T>& rhs){
-		valarray<T> retval(lhs);
-		retval -= rhs;
-		return retval;
-	}
-	template<class T> valarray<T> operator- (const valarray<T>& lhs, const T& rhs){
-		valarray<T> retval(lhs);
-		retval -= rhs;
-		return retval;
-	}
-	template<class T> valarray<T> operator- (const T& lhs, const valarray<T>& rhs){
-		valarray<T> retval(lhs, rhs.size());
-		retval -= rhs;
-		return retval;
-	}
-	template<class T> valarray<T> operator^ (const valarray<T>& lhs, const valarray<T>& rhs){
-		valarray<T> retval(lhs);
-		retval ^= rhs;
-		return retval;
-	}
-	template<class T> valarray<T> operator^ (const valarray<T>& lhs, const T& rhs){
-		valarray<T> retval(lhs);
-		retval ^= rhs;
-		return retval;
-	}
-	template<class T> valarray<T> operator^ (const T& lhs, const valarray<T>& rhs){
-		valarray<T> retval(lhs, rhs.size());
-		retval ^= rhs;
-		return retval;
-	}
-	template<class T> valarray<T> operator& (const valarray<T>& lhs, const valarray<T>& rhs){
-		valarray<T> retval(lhs);
-		retval &= rhs;
-		return retval;
-	}
-	template<class T> valarray<T> operator& (const valarray<T>& lhs, const T& rhs){
-		valarray<T> retval(lhs);
-		retval &= rhs;
-		return retval;
-	}
-	template<class T> valarray<T> operator& (const T& lhs, const valarray<T>& rhs){
-		valarray<T> retval(lhs, rhs.size());
-		retval &= rhs;
-		return retval;
-	}
-	template<class T> valarray<T> operator| (const valarray<T>& lhs, const valarray<T>& rhs){
-		valarray<T> retval(lhs);
-		retval |= rhs;
-		return retval;
-	}
-	template<class T> valarray<T> operator| (const valarray<T>& lhs, const T& rhs){
-		valarray<T> retval(lhs);
-		retval |= rhs;
-		return retval;
-	}
-	template<class T> valarray<T> operator| (const T& lhs, const valarray<T>& rhs){
-		valarray<T> retval(lhs, rhs.size());
-		retval |= rhs;
-		return retval;
-	}
-	template<class T> valarray<T> operator<<(const valarray<T>& lhs, const valarray<T>& rhs){
-		valarray<T> retval(lhs);
-		retval <<= rhs;
-		return retval;
-	}
-	template<class T> valarray<T> operator<<(const valarray<T>& lhs, const T& rhs){
-		valarray<T> retval(lhs);
-		retval <<= rhs;
-		return retval;
-	}
-	template<class T> valarray<T> operator<<(const T& lhs, const valarray<T>& rhs){
-		valarray<T> retval(lhs, rhs.size());
-		retval <<= rhs;
-		return retval;
-	}
-	template<class T> valarray<T> operator>>(const valarray<T>& lhs, const valarray<T>& rhs){
-		valarray<T> retval(lhs);
-		retval >>= rhs;
-		return retval;
-	}
-	template<class T> valarray<T> operator>>(const valarray<T>& lhs, const T& rhs){
-		valarray<T> retval(lhs);
-		retval >>= rhs;
-		return retval;
-	}
-	template<class T> valarray<T> operator>>(const T& lhs, const valarray<T>& rhs){
-		valarray<T> retval(lhs, rhs.size());
-		retval >>= rhs;
-		return retval;
-	}
-
-	template<class T> valarray<bool> operator&&(const valarray<T>& lhs, const valarray<T>& rhs){
-		valarray<bool> retval(lhs.size());
-		for(size_t i = 0; i < retval.size(); ++i){
-			retval[i] = lhs[i] && rhs[i];
-		}
-		return retval;
-	}
-	template<class T> valarray<bool> operator&&(const valarray<T>& lhs, const T& rhs){
-		valarray<bool> retval(lhs.size());
-		for(size_t i = 0; i <retval.size(); ++i){
-			retval[i] = lhs[i] && rhs;
-		}
-		return retval;
-	}
-	template<class T> valarray<bool> operator&&(const T& lhs, const valarray<T>& rhs){
-		valarray<bool> retval(rhs.size());
-		for(size_t i = 0; i <retval.size(); ++i){
-			retval[i] = lhs && rhs[i];
-		}
-		return retval;
-	}
-	template<class T> valarray<bool> operator||(const valarray<T>&lhs, const valarray<T>& rhs){
-		valarray<bool> retval(lhs.size());
-		for(size_t i = 0; i <retval.size(); ++i){
-			retval[i] = lhs[i] || rhs[i];
-		}
-		return retval;
-	}
-	template<class T> valarray<bool> operator||(const valarray<T>& lhs, const T& rhs){
-		valarray<bool> retval(lhs.size());
-		for(size_t i = 0; i <retval.size(); ++i){
-			retval[i] = lhs[i] || rhs;
-		}
-		return retval;
-	}
-	template<class T> valarray<bool> operator||(const T& lhs, const valarray<T>& rhs){
-		valarray<bool> retval(rhs.size());
-		for(size_t i = 0; i < retval.size(); ++i){
-			retval[i] = lhs || rhs[i];
-		}
-		return retval;
-	}
-
-	template<class T> valarray<bool> operator==(const valarray<T>& lhs, const valarray<T>& rhs){
-		valarray<bool> retval(lhs.size());
-		for(size_t i = 0; i <retval.size(); ++i){
-			retval[i] = lhs[i] == rhs[i];
-		}
-		return retval;
-	}
-	template<class T> valarray<bool> operator==(const valarray<T>& lhs, const T& rhs){
-		valarray<bool> retval(lhs.size());
-		for(size_t i = 0; i < retval.size(); ++i){
-			retval[i] = lhs[i] == rhs;
-		}
-		return retval;
-	}
-	template<class T> valarray<bool> operator==(const T& lhs, const valarray<T>& rhs){
-		valarray<bool> retval(rhs.size());
-		for(size_t i = 0; i < retval.size(); ++i){
-			retval[i] = lhs == rhs[i];
-		}
-		return retval;
-	}
-	template<class T> valarray<bool> operator!=(const valarray<T>& lhs, const valarray<T>& rhs){
-		valarray<bool> retval(lhs.size());
-		for(size_t i = 0; i <retval.size(); ++i){
-			retval[i] = lhs[i] != rhs[i];
-		}
-		return retval;
-	}
-	template<class T> valarray<bool> operator!=(const valarray<T>& lhs, const T& rhs){
-		valarray<bool> retval(lhs.size());
-		for(size_t i = 0; i <retval.size(); ++i){
-			retval[i] = lhs[i] != rhs;
-		}
-		return retval;
-	}
-	template<class T> valarray<bool> operator!=(const T& lhs, const valarray<T>& rhs){
-		valarray<bool> retval(rhs.size());
-		for(size_t i = 0; i <retval.size(); ++i){
-			retval[i] = lhs != rhs[i];
-		}
-		return retval;
-	}
-	template<class T> valarray<bool> operator< (const valarray<T>& lhs, const valarray<T>& rhs){
-		valarray<bool> retval(lhs.size());
-		for(size_t i = 0; i <retval.size(); ++i){
-			retval[i] = lhs[i] < rhs[i];
-		}
-		return retval;
-	}
-	template<class T> valarray<bool> operator< (const valarray<T>& lhs, const T& rhs){
-		valarray<bool> retval(lhs.size());
-		for(size_t i = 0; i <retval.size(); ++i){
-			retval[i] = lhs[i] < rhs;
-		}
-		return retval;
-	}
-	template<class T> valarray<bool> operator< (const T& lhs, const valarray<T>& rhs){
-		valarray<bool> retval(rhs.size());
-		for(size_t i = 0; i <retval.size(); ++i){
-			retval[i] = lhs < rhs[i];
-		}
-		return retval;
-	}
-	template<class T> valarray<bool> operator> (const valarray<T>& lhs, const valarray<T>& rhs){
-		valarray<bool> retval(lhs.size());
-		for(size_t i = 0; i <retval.size(); ++i){
-			retval[i] = lhs[i] > rhs[i];
-		}
-		return retval;
-	}
-	template<class T> valarray<bool> operator> (const valarray<T>& lhs, const T& rhs){
-		valarray<bool> retval(lhs.size());
-		for(size_t i = 0; i <retval.size(); ++i){
-			retval[i] = lhs[i] > rhs;
-		}
-		return retval;
-	}
-	template<class T> valarray<bool> operator> (const T& lhs, const valarray<T>& rhs){
-		valarray<bool> retval(rhs.size());
-		for(size_t i = 0; i <retval.size(); ++i){
-			retval[i] = lhs > rhs[i];
-		}
-		return retval;
-	}
-	template<class T> valarray<bool> operator<=(const valarray<T>& lhs, const valarray<T>& rhs){
-		valarray<bool> retval(lhs.size());
-		for(size_t i = 0; i <retval.size(); ++i){
-			retval[i] = lhs[i] <= rhs[i];
-		}
-		return retval;
-	}
-	template<class T> valarray<bool> operator<=(const valarray<T>& lhs, const T& rhs){
-		valarray<bool> retval(lhs.size());
-		for(size_t i = 0; i <retval.size(); ++i){
-			retval[i] = lhs[i] <= rhs;
-		}
-		return retval;
-	}
-	template<class T> valarray<bool> operator<=(const T& lhs, const valarray<T>& rhs){
-		valarray<bool> retval(rhs.size());
-		for(size_t i = 0; i <retval.size(); ++i){
-			retval[i] = lhs <= rhs[i];
-		}
-		return retval;
-	}
-	template<class T> valarray<bool> operator>=(const valarray<T>& lhs, const valarray<T>& rhs){
-		valarray<bool> retval(lhs.size());
-		for(size_t i = 0; i <retval.size(); ++i){
-			retval[i] = lhs[i] >= rhs[i];
-		}
-		return retval;
-	}
-	template<class T> valarray<bool> operator>=(const valarray<T>& lhs, const T& rhs){
-		valarray<bool> retval(lhs.size());
-		for(size_t i = 0; i <retval.size(); ++i){
-			retval[i] = lhs[i] >= rhs;
-		}
-		return retval;
-	}
-	template<class T> valarray<bool> operator>=(const T& lhs, const valarray<T>& rhs){
-		valarray<bool> retval(rhs.size());
-		for(size_t i = 0; i <retval.size(); ++i){
-			retval[i] = lhs >= rhs[i];
-		}
-		return retval;
-	}
-	template<class T> T min(const valarray<T>& x){
-		T retval(x[0]);
-		for(size_t i = 1; i < x.size(); ++i){
-			if(x[i] < retval){
-				retval = x[i];
-			}
-		}
-	}
-	template<class T> T max(const valarray<T>& x){
-		T retval(x[0]);
-		for(size_t i = 1; i < x.size(); ++i){
-			if(x[i] > retval){
-				retval = x[i];
-			}
-		}
-	}
-
-	template<class T> valarray<T> abs  (const valarray<T>& x){
-		valarray<T> retval(x.size());
-		for(size_t i = 0; i < retval.size(); ++i){
-			retval[i] = abs(x[i]);
-		}
-		return retval;
-	}
-	template<class T> valarray<T> acos (const valarray<T>& x){
-		valarray<T> retval(x.size());
-		for(size_t i = 0; i < retval.size(); ++i){
-			retval[i] = acos(x[i]);
-		}
-		return retval;
-	}
-	template<class T> valarray<T> asin (const valarray<T>& x){
-		valarray<T> retval(x.size());
-		for(size_t i = 0; i < retval.size(); ++i){
-			retval[i] = asin(x[i]);
-		}
-		return retval;
-	}
-	template<class T> valarray<T> atan (const valarray<T>& x){
-		valarray<T> retval(x.size());
-		for(size_t i = 0; i < retval.size(); ++i){
-			retval[i] = atan(x[i]);
-		}
-		return retval;
-	}
-	template<class T> valarray<T> atan2(const valarray<T>& y, const valarray<T>& x){
-		valarray<T> retval(y.size());
-		for(size_t i = 0; i < retval.size(); ++i){
-			retval[i] = atan2(y[i], x[i]);
-		}
-		return retval;
-	}
-	template<class T> valarray<T> atan2(const valarray<T>& y, const T& x){
-		valarray<T> retval(y.size());
-		for(size_t i = 0; i < retval.size(); ++i){
-			retval[i] = atan2(y[i], x);
-		}
-		return retval;
-	}
-	template<class T> valarray<T> atan2(const T& y, const valarray<T>& x){
-		valarray<T> retval(x.size());
-		for(size_t i = 0; i < retval.size(); ++i){
-			retval[i] = atan2(y, x[i]);
-		}
-		return retval;
-	}
-	template<class T> valarray<T> cos  (const valarray<T>& x){
-		valarray<T> retval(x.size());
-		for(size_t i = 0; i < retval.size(); ++i){
-			retval[i] = cos(x[i]);
-		}
-		return retval;
-	}
-	template<class T> valarray<T> cosh (const valarray<T>& x){
-		valarray<T> retval(x.size());
-		for(size_t i = 0; i < retval.size(); ++i){
-			retval[i] = cosh(x[i]);
-		}
-		return retval;
-	}
-	template<class T> valarray<T> exp  (const valarray<T>& x){
-		valarray<T> retval(x.size());
-		for(size_t i = 0; i < retval.size(); ++i){
-			retval[i] = exp(x[i]);
-		}
-		return retval;
-	}
-	template<class T> valarray<T> log  (const valarray<T>& x){
-		valarray<T> retval(x.size());
-		for(size_t i = 0; i < retval.size(); ++i){
-			retval[i] = log(x[i]);
-		}
-		return retval;
-	}
-	template<class T> valarray<T> log10(const valarray<T>& x){
-		valarray<T> retval(x.size());
-		for(size_t i = 0; i < retval.size(); ++i){
-			retval[i] = log10(x[i]);
-		}
-		return retval;
-	}
-	template<class T> valarray<T> pow  (const valarray<T>& x, const valarray<T>& y){
-		valarray<T> retval(x.size());
-		for(size_t i = 0; i < retval.size(); ++i){
-			retval[i] = pow(x[i], y[i]);
-		}
-		return retval;
-	}
-	template<class T> valarray<T> pow  (const valarray<T>& x, const T& y){
-		valarray<T> retval(x.size());
-		for(size_t i = 0; i < retval.size(); ++i){
-			retval[i] = pow(x[i], y);
-		}
-		return retval;
-	}
-	template<class T> valarray<T> pow  (const T& x, const valarray<T>& y){
-		valarray<T> retval(y.size());
-		for(size_t i = 0; i < retval.size(); ++i){
-			retval[i] = pow(x, y[i]);
-		}
-		return retval;
-	}
-	template<class T> valarray<T> sin  (const valarray<T>& x){
-		valarray<T> retval(x.size());
-		for(size_t i = 0; i < retval.size(); ++i){
-			retval[i] = sin(x[i]);
-		}
-		return retval;
-	}
-	template<class T> valarray<T> sinh (const valarray<T>& x){
-		valarray<T> retval(x.size());
-		for(size_t i = 0; i < retval.size(); ++i){
-			retval[i] = sinh(x[i]);
-		}
-		return retval;
-	}
-	template<class T> valarray<T> sqrt (const valarray<T>& x){
-		valarray<T> retval(x.size());
-		for(size_t i = 0; i < retval.size(); ++i){
-			retval[i] = sqrt(x[i]);
-		}
-		return retval;
-	}
-	template<class T> valarray<T> tan  (const valarray<T>& x){
-		valarray<T> retval(x.size());
-		for(size_t i = 0; i < retval.size(); ++i){
-			retval[i] = tan(x[i]);
-		}
-		return retval;
-	}
-	template<class T> valarray<T> tanh (const valarray<T>& x){
-		valarray<T> retval(x.size());
-		for(size_t i = 0; i < retval.size(); ++i){
-			retval[i] = tanh(x[i]);
-		}
-		return retval;
-	}
-}
+    void operator=(const T&);  
+
+  private:
+    gslice_array();
+    gslice_array(const gslice_array<T>&);
+    gslice_array<T>& operator= (const gslice_array<T>& array);
+  };
+
+  template<class T> valarray<T> operator* (const valarray<T>& lhs, const valarray<T>& rhs)
+  {
+    valarray<T> retval(lhs);
+    retval *= rhs;
+    return retval;
+  }
+
+  template<class T> valarray<T> operator* (const valarray<T>& lhs, const T& rhs)
+  {
+    valarray<T> retval(lhs);
+    retval *= rhs;
+    return retval;
+  }
+
+  template<class T> valarray<T> operator* (const T& lhs, const valarray<T>& rhs)
+  {
+    valarray<T> retval(rhs);
+    retval *= lhs;
+    return retval;
+  }
+
+  template<class T> valarray<T> operator/ (const valarray<T>& lhs, const valarray<T>& rhs)
+  {
+    valarray<T> retval(lhs);
+    retval /= rhs;
+    return retval;
+  }
+
+  template<class T> valarray<T> operator/ (const valarray<T>& lhs, const T& rhs)
+  {
+    valarray<T> retval(lhs);
+    retval /= rhs;
+    return retval;
+  }
+
+  template<class T> valarray<T> operator/ (const T& lhs, const valarray<T>& rhs)
+  {
+    valarray<T> retval(lhs, rhs.size());
+    retval /= rhs;
+    return retval;
+  }
+
+  template<class T> valarray<T> operator% (const valarray<T>& lhs, const valarray<T>& rhs)
+  {
+    valarray<T> retval(lhs);
+    retval %= rhs;
+    return retval;
+  }
+
+  template<class T> valarray<T> operator% (const valarray<T>& lhs, const T& rhs)
+  {
+    valarray<T> retval(lhs);
+    retval %= rhs;
+    return retval;
+  }
+
+  template<class T> valarray<T> operator% (const T& lhs, const valarray<T>& rhs)
+  {
+    valarray<T> retval(lhs, rhs.size());
+    retval %= rhs;
+    return retval;
+  }
+
+  template<class T> valarray<T> operator+ (const valarray<T>& lhs, const valarray<T>& rhs)
+  {
+    valarray<T> retval(lhs);
+    retval += rhs;
+    return retval;
+  }
+
+  template<class T> valarray<T> operator+ (const valarray<T>& lhs, const T& rhs)
+  {
+    valarray<T> retval(lhs);
+    retval += rhs;
+    return retval;
+  }
+
+  template<class T> valarray<T> operator+ (const T& lhs, const valarray<T>& rhs)
+  {
+    valarray<T> retval(lhs, rhs.size());
+    retval += rhs;
+    return retval;
+  }
+
+  template<class T> valarray<T> operator- (const valarray<T>& lhs, const valarray<T>& rhs)
+  {
+    valarray<T> retval(lhs);
+    retval -= rhs;
+    return retval;
+  }
+
+  template<class T> valarray<T> operator- (const valarray<T>& lhs, const T& rhs)
+  {
+    valarray<T> retval(lhs);
+    retval -= rhs;
+    return retval;
+  }
+
+  template<class T> valarray<T> operator- (const T& lhs, const valarray<T>& rhs)
+  {
+    valarray<T> retval(lhs, rhs.size());
+    retval -= rhs;
+    return retval;
+  }
+
+  template<class T> valarray<T> operator^ (const valarray<T>& lhs, const valarray<T>& rhs)
+  {
+    valarray<T> retval(lhs);
+    retval ^= rhs;
+    return retval;
+  }
+
+  template<class T> valarray<T> operator^ (const valarray<T>& lhs, const T& rhs)
+  {
+    valarray<T> retval(lhs);
+    retval ^= rhs;
+    return retval;
+  }
+
+  template<class T> valarray<T> operator^ (const T& lhs, const valarray<T>& rhs)
+  {
+    valarray<T> retval(lhs, rhs.size());
+    retval ^= rhs;
+    return retval;
+  }
+
+  template<class T> valarray<T> operator& (const valarray<T>& lhs, const valarray<T>& rhs)
+  {
+    valarray<T> retval(lhs);
+    retval &= rhs;
+    return retval;
+  }
+
+  template<class T> valarray<T> operator& (const valarray<T>& lhs, const T& rhs)
+  {
+    valarray<T> retval(lhs);
+    retval &= rhs;
+    return retval;
+  }
+
+  template<class T> valarray<T> operator& (const T& lhs, const valarray<T>& rhs)
+  {
+    valarray<T> retval(lhs, rhs.size());
+    retval &= rhs;
+    return retval;
+  }
+
+  template<class T> valarray<T> operator| (const valarray<T>& lhs, const valarray<T>& rhs)
+  {
+    valarray<T> retval(lhs);
+    retval |= rhs;
+    return retval;
+  }
+
+  template<class T> valarray<T> operator| (const valarray<T>& lhs, const T& rhs)
+  {
+    valarray<T> retval(lhs);
+    retval |= rhs;
+    return retval;
+  }
+
+  template<class T> valarray<T> operator| (const T& lhs, const valarray<T>& rhs)
+  {
+    valarray<T> retval(lhs, rhs.size());
+    retval |= rhs;
+    return retval;
+  }
+
+  template<class T> valarray<T> operator<<(const valarray<T>& lhs, const valarray<T>& rhs)
+  {
+    valarray<T> retval(lhs);
+    retval <<= rhs;
+    return retval;
+  }
+
+  template<class T> valarray<T> operator<<(const valarray<T>& lhs, const T& rhs)
+  {
+    valarray<T> retval(lhs);
+    retval <<= rhs;
+    return retval;
+  }
+
+  template<class T> valarray<T> operator<<(const T& lhs, const valarray<T>& rhs)
+  {
+    valarray<T> retval(lhs, rhs.size());
+    retval <<= rhs;
+    return retval;
+  }
+
+  template<class T> valarray<T> operator>>(const valarray<T>& lhs, const valarray<T>& rhs)
+  {
+    valarray<T> retval(lhs);
+    retval >>= rhs;
+    return retval;
+  }
+
+  template<class T> valarray<T> operator>>(const valarray<T>& lhs, const T& rhs)
+  {
+    valarray<T> retval(lhs);
+    retval >>= rhs;
+    return retval;
+  }
+
+  template<class T> valarray<T> operator>>(const T& lhs, const valarray<T>& rhs)
+  {
+    valarray<T> retval(lhs, rhs.size());
+    retval >>= rhs;
+    return retval;
+  }
+
+  template<class T> valarray<bool> operator&&(const valarray<T>& lhs, const valarray<T>& rhs)
+  {
+    valarray<bool> retval(lhs.size());
+
+    for (size_t i = 0; i < retval.size(); ++i)
+    {
+      retval[i] = lhs[i] && rhs[i];
+    }
+
+    return retval;
+  }
+
+  template<class T> valarray<bool> operator&&(const valarray<T>& lhs, const T& rhs)
+  {
+    valarray<bool> retval(lhs.size());
+
+    for (size_t i = 0; i <retval.size(); ++i)
+    {
+      retval[i] = lhs[i] && rhs;
+    }
+
+    return retval;
+  }
+
+  template<class T> valarray<bool> operator&&(const T& lhs, const valarray<T>& rhs)
+  {
+    valarray<bool> retval(rhs.size());
+
+    for (size_t i = 0; i <retval.size(); ++i)
+    {
+      retval[i] = lhs && rhs[i];
+    }
+
+    return retval;
+  }
+
+  template<class T> valarray<bool> operator||(const valarray<T>&lhs, const valarray<T>& rhs)
+  {
+    valarray<bool> retval(lhs.size());
+
+    for (size_t i = 0; i <retval.size(); ++i)
+    {
+      retval[i] = lhs[i] || rhs[i];
+    }
+
+    return retval;
+  }
+
+  template<class T> valarray<bool> operator||(const valarray<T>& lhs, const T& rhs)
+  {
+    valarray<bool> retval(lhs.size());
+
+    for (size_t i = 0; i <retval.size(); ++i)
+    {
+      retval[i] = lhs[i] || rhs;
+    }
+
+    return retval;
+  }
+
+  template<class T> valarray<bool> operator||(const T& lhs, const valarray<T>& rhs)
+  {
+    valarray<bool> retval(rhs.size());
+
+    for (size_t i = 0; i < retval.size(); ++i)
+    {
+      retval[i] = lhs || rhs[i];
+    }
+
+    return retval;
+  }
+
+  template<class T> valarray<bool> operator==(const valarray<T>& lhs, const valarray<T>& rhs)
+  {
+    valarray<bool> retval(lhs.size());
+
+    for (size_t i = 0; i <retval.size(); ++i)
+    {
+      retval[i] = lhs[i] == rhs[i];
+    }
+
+    return retval;
+  }
+
+  template<class T> valarray<bool> operator==(const valarray<T>& lhs, const T& rhs)
+  {
+    valarray<bool> retval(lhs.size());
+
+    for (size_t i = 0; i < retval.size(); ++i)
+    {
+      retval[i] = lhs[i] == rhs;
+    }
+
+    return retval;
+  }
+
+  template<class T> valarray<bool> operator==(const T& lhs, const valarray<T>& rhs)
+  {
+    valarray<bool> retval(rhs.size());
+
+    for (size_t i = 0; i < retval.size(); ++i)
+    {
+      retval[i] = lhs == rhs[i];
+    }
+
+    return retval;
+  }
+
+  template<class T> valarray<bool> operator!=(const valarray<T>& lhs, const valarray<T>& rhs)
+  {
+    valarray<bool> retval(lhs.size());
+
+    for (size_t i = 0; i <retval.size(); ++i)
+    {
+      retval[i] = lhs[i] != rhs[i];
+    }
+
+    return retval;
+  }
+
+  template<class T> valarray<bool> operator!=(const valarray<T>& lhs, const T& rhs)
+  {
+    valarray<bool> retval(lhs.size());
+
+    for (size_t i = 0; i <retval.size(); ++i)
+    {
+      retval[i] = lhs[i] != rhs;
+    }
+
+    return retval;
+  }
+
+  template<class T> valarray<bool> operator!=(const T& lhs, const valarray<T>& rhs)
+  {
+    valarray<bool> retval(rhs.size());
+
+    for (size_t i = 0; i <retval.size(); ++i)
+    {
+      retval[i] = lhs != rhs[i];
+    }
+
+    return retval;
+  }
+
+  template<class T> valarray<bool> operator< (const valarray<T>& lhs, const valarray<T>& rhs)
+  {
+    valarray<bool> retval(lhs.size());
+
+    for (size_t i = 0; i <retval.size(); ++i)
+    {
+      retval[i] = lhs[i] < rhs[i];
+    }
+
+    return retval;
+  }
+
+  template<class T> valarray<bool> operator< (const valarray<T>& lhs, const T& rhs)
+  {
+    valarray<bool> retval(lhs.size());
+
+    for (size_t i = 0; i <retval.size(); ++i)
+    {
+      retval[i] = lhs[i] < rhs;
+    }
+
+    return retval;
+  }
+
+  template<class T> valarray<bool> operator< (const T& lhs, const valarray<T>& rhs)
+  {
+    valarray<bool> retval(rhs.size());
+
+    for (size_t i = 0; i <retval.size(); ++i)
+    {
+      retval[i] = lhs < rhs[i];
+    }
+
+    return retval;
+  }
+
+  template<class T> valarray<bool> operator> (const valarray<T>& lhs, const valarray<T>& rhs)
+  {
+    valarray<bool> retval(lhs.size());
+
+    for (size_t i = 0; i <retval.size(); ++i)
+    {
+      retval[i] = lhs[i] > rhs[i];
+    }
+
+    return retval;
+  }
+
+  template<class T> valarray<bool> operator> (const valarray<T>& lhs, const T& rhs)
+  {
+    valarray<bool> retval(lhs.size());
+
+    for (size_t i = 0; i <retval.size(); ++i)
+    {
+      retval[i] = lhs[i] > rhs;
+    }
+
+    return retval;
+  }
+
+  template<class T> valarray<bool> operator> (const T& lhs, const valarray<T>& rhs)
+  {
+    valarray<bool> retval(rhs.size());
+
+    for (size_t i = 0; i <retval.size(); ++i)
+    {
+      retval[i] = lhs > rhs[i];
+    }
+
+    return retval;
+  }
+
+  template<class T> valarray<bool> operator<=(const valarray<T>& lhs, const valarray<T>& rhs)
+  {
+    valarray<bool> retval(lhs.size());
+
+    for (size_t i = 0; i <retval.size(); ++i)
+    {
+      retval[i] = lhs[i] <= rhs[i];
+    }
+
+    return retval;
+  }
+
+  template<class T> valarray<bool> operator<=(const valarray<T>& lhs, const T& rhs)
+  {
+    valarray<bool> retval(lhs.size());
+
+    for (size_t i = 0; i <retval.size(); ++i)
+    {
+      retval[i] = lhs[i] <= rhs;
+    }
+
+    return retval;
+  }
+
+  template<class T> valarray<bool> operator<=(const T& lhs, const valarray<T>& rhs)
+  {
+    valarray<bool> retval(rhs.size());
+
+    for (size_t i = 0; i <retval.size(); ++i)
+    {
+      retval[i] = lhs <= rhs[i];
+    }
+
+    return retval;
+  }
+
+  template<class T> valarray<bool> operator>=(const valarray<T>& lhs, const valarray<T>& rhs)
+  {
+    valarray<bool> retval(lhs.size());
+
+    for (size_t i = 0; i <retval.size(); ++i)
+    {
+      retval[i] = lhs[i] >= rhs[i];
+    }
+
+    return retval;
+  }
+
+  template<class T> valarray<bool> operator>=(const valarray<T>& lhs, const T& rhs)
+  {
+    valarray<bool> retval(lhs.size());
+
+    for (size_t i = 0; i <retval.size(); ++i)
+    {
+      retval[i] = lhs[i] >= rhs;
+    }
+
+    return retval;
+  }
+
+  template<class T> valarray<bool> operator>=(const T& lhs, const valarray<T>& rhs)
+  {
+    valarray<bool> retval(rhs.size());
+
+    for (size_t i = 0; i <retval.size(); ++i)
+    {
+      retval[i] = lhs >= rhs[i];
+    }
+
+    return retval;
+  }
+
+  template<class T> T min(const valarray<T>& x)
+  {
+    T retval(x[0]);
+
+    for (size_t i = 1; i < x.size(); ++i)
+    {
+      if (x[i] < retval)
+      {
+        retval = x[i];
+      }
+    }
+  }
+
+  template<class T> T max(const valarray<T>& x)
+  {
+    T retval(x[0]);
+
+    for (size_t i = 1; i < x.size(); ++i)
+    {
+      if (x[i] > retval)
+      {
+        retval = x[i];
+      }
+    }
+  }
+
+  template<class T> valarray<T> abs  (const valarray<T>& x)
+  {
+    valarray<T> retval(x.size());
+
+    for (size_t i = 0; i < retval.size(); ++i)
+    {
+      retval[i] = abs(x[i]);
+    }
+
+    return retval;
+  }
+
+  template<class T> valarray<T> acos (const valarray<T>& x)
+  {
+    valarray<T> retval(x.size());
+
+    for (size_t i = 0; i < retval.size(); ++i)
+    {
+      retval[i] = acos(x[i]);
+    }
+
+    return retval;
+  }
+
+  template<class T> valarray<T> asin (const valarray<T>& x)
+  {
+    valarray<T> retval(x.size());
+
+    for (size_t i = 0; i < retval.size(); ++i)
+    {
+      retval[i] = asin(x[i]);
+    }
+
+    return retval;
+  }
+
+  template<class T> valarray<T> atan (const valarray<T>& x)
+  {
+    valarray<T> retval(x.size());
+
+    for (size_t i = 0; i < retval.size(); ++i)
+    {
+      retval[i] = atan(x[i]);
+    }
+
+    return retval;
+  }
+
+  template<class T> valarray<T> atan2(const valarray<T>& y, const valarray<T>& x)
+  {
+    valarray<T> retval(y.size());
+
+    for (size_t i = 0; i < retval.size(); ++i)
+    {
+      retval[i] = atan2(y[i], x[i]);
+    }
+
+    return retval;
+  }
+
+  template<class T> valarray<T> atan2(const valarray<T>& y, const T& x)
+  {
+    valarray<T> retval(y.size());
+
+    for (size_t i = 0; i < retval.size(); ++i)
+    {
+      retval[i] = atan2(y[i], x);
+    }
+
+    return retval;
+  }
+
+  template<class T> valarray<T> atan2(const T& y, const valarray<T>& x)
+  {
+    valarray<T> retval(x.size());
+
+    for (size_t i = 0; i < retval.size(); ++i)
+    {
+      retval[i] = atan2(y, x[i]);
+    }
+
+    return retval;
+  }
+
+  template<class T> valarray<T> cos  (const valarray<T>& x)
+  {
+    valarray<T> retval(x.size());
+
+    for (size_t i = 0; i < retval.size(); ++i)
+    {
+      retval[i] = cos(x[i]);
+    }
+
+    return retval;
+  }
+
+  template<class T> valarray<T> cosh (const valarray<T>& x)
+  {
+    valarray<T> retval(x.size());
+
+    for (size_t i = 0; i < retval.size(); ++i)
+    {
+      retval[i] = cosh(x[i]);
+    }
+
+    return retval;
+  }
+
+  template<class T> valarray<T> exp  (const valarray<T>& x)
+  {
+    valarray<T> retval(x.size());
+
+    for (size_t i = 0; i < retval.size(); ++i)
+    {
+      retval[i] = exp(x[i]);
+    }
+
+    return retval;
+  }
+
+  template<class T> valarray<T> log  (const valarray<T>& x)
+  {
+    valarray<T> retval(x.size());
+
+    for (size_t i = 0; i < retval.size(); ++i)
+    {
+      retval[i] = log(x[i]);
+    }
+
+    return retval;
+  }
+
+  template<class T> valarray<T> log10(const valarray<T>& x)
+  {
+    valarray<T> retval(x.size());
+
+    for (size_t i = 0; i < retval.size(); ++i)
+    {
+      retval[i] = log10(x[i]);
+    }
+
+    return retval;
+  }
+
+  template<class T> valarray<T> pow  (const valarray<T>& x, const valarray<T>& y)
+  {
+    valarray<T> retval(x.size());
+
+    for (size_t i = 0; i < retval.size(); ++i)
+    {
+      retval[i] = pow(x[i], y[i]);
+    }
+
+    return retval;
+  }
+
+  template<class T> valarray<T> pow  (const valarray<T>& x, const T& y)
+  {
+    valarray<T> retval(x.size());
+
+    for (size_t i = 0; i < retval.size(); ++i)
+    {
+      retval[i] = pow(x[i], y);
+    }
+
+    return retval;
+  }
+
+  template<class T> valarray<T> pow  (const T& x, const valarray<T>& y)
+  {
+    valarray<T> retval(y.size());
+
+    for (size_t i = 0; i < retval.size(); ++i)
+    {
+      retval[i] = pow(x, y[i]);
+    }
+
+    return retval;
+  }
+
+  template<class T> valarray<T> sin  (const valarray<T>& x)
+  {
+    valarray<T> retval(x.size());
+
+    for (size_t i = 0; i < retval.size(); ++i)
+    {
+      retval[i] = sin(x[i]);
+    }
+
+    return retval;
+  }
+
+  template<class T> valarray<T> sinh (const valarray<T>& x)
+  {
+    valarray<T> retval(x.size());
+
+    for (size_t i = 0; i < retval.size(); ++i)
+    {
+      retval[i] = sinh(x[i]);
+    }
+
+    return retval;
+  }
+
+  template<class T> valarray<T> sqrt (const valarray<T>& x)
+  {
+    valarray<T> retval(x.size());
+
+    for (size_t i = 0; i < retval.size(); ++i)
+    {
+      retval[i] = sqrt(x[i]);
+    }
+
+    return retval;
+  }
+
+  template<class T> valarray<T> tan  (const valarray<T>& x)
+  {
+    valarray<T> retval(x.size());
+
+    for (size_t i = 0; i < retval.size(); ++i){
+      retval[i] = tan(x[i]);
+    }
+
+    return retval;
+  }
+
+  template<class T> valarray<T> tanh (const valarray<T>& x)
+  {
+    valarray<T> retval(x.size());
+
+    for (size_t i = 0; i < retval.size(); ++i)
+    {
+      retval[i] = tanh(x[i]);
+    }
+
+    return retval;
+  }
+
+} // namespace
+} // extern "C++"
 
 #pragma GCC visibility pop
 
diff --git a/misc/uClibc++/include/uClibc++/vector b/misc/uClibc++/include/uClibc++/vector
index 8310bc14e..88adbd011 100644
--- a/misc/uClibc++/include/uClibc++/vector
+++ b/misc/uClibc++/include/uClibc++/vector
@@ -1,22 +1,21 @@
-/*	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
-
-*/
+/*  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>
@@ -25,491 +24,582 @@
 #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;
-		}
-	}
-
+extern "C++"
+{
+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();
+  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);
+  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();
-
+  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);
+  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);
-	}
-
-}
+  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);
+  }
+
+} // namespace
+} // extern "C++"
 
 #pragma GCC visibility pop
 
diff --git a/misc/uClibc++/libxx/uClibc++/associative_base.cxx b/misc/uClibc++/libxx/uClibc++/associative_base.cxx
index cc2d20e54..6a7d786e4 100644
--- a/misc/uClibc++/libxx/uClibc++/associative_base.cxx
+++ b/misc/uClibc++/libxx/uClibc++/associative_base.cxx
@@ -1,26 +1,24 @@
-/*	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
-
-*/
+/* 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{
-
-
-
-}
+namespace std
+{
+} // namespace
diff --git a/misc/uClibc++/libxx/uClibc++/bitset.cxx b/misc/uClibc++/libxx/uClibc++/bitset.cxx
index f1ece31f9..735d863fd 100644
--- a/misc/uClibc++/libxx/uClibc++/bitset.cxx
+++ b/misc/uClibc++/libxx/uClibc++/bitset.cxx
@@ -1,26 +1,24 @@
-/*	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
-
-*/
+/* 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{
-
-
-
-}
+namespace std
+{
+} // namespace