/elec/propeller-clock : contents of src/utility/ostream at revision 57

: (revision 57)

To get this branch, use:

bzr branch
http://bzr.ed.am/elec/propeller-clock

/*	Copyright (C) 2004-2008 Garrett A. Kajmowicz

	This file is part of the uClibc++ Library.

	This library is free software; you can redistribute it and/or
	modify it under the terms of the GNU Lesser General Public
	License as published by the Free Software Foundation; either
	version 2.1 of the License, or (at your option) any later version.

	This library is distributed in the hope that it will be useful,
	but WITHOUT ANY WARRANTY; without even the implied warranty of
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
	Lesser General Public License for more details.

	You should have received a copy of the GNU Lesser General Public
	License along with this library; if not, write to the Free Software
	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/

#include <basic_definitions>

#ifndef STD_HEADER_OSTREAM
#define STD_HEADER_OSTREAM 1

#include <iosfwd>
#include <streambuf>
#include <cstdio>
#include <ostream_helpers>

#if defined( __AVR__ )
#include <avr/pgmspace.h>
class __FlashStringHelper;
#endif

#pragma GCC visibility push(default)

namespace std {
	template <class charT, class traits > class basic_ostream;
	typedef basic_ostream<char> ostream;

#ifdef __UCLIBCXX_HAS_WCHAR__
	typedef basic_ostream<wchar_t> wostream;
#endif

	template <class charT, class traits> basic_ostream<charT,traits>& endl(basic_ostream<charT,traits>& os);
	template <class charT, class traits> basic_ostream<charT,traits>& ends(basic_ostream<charT,traits>& os);
	template <class charT, class traits> basic_ostream<charT,traits>& flush(basic_ostream<charT,traits>& os);

	template <class charT, class traits > class _UCXXEXPORT basic_ostream
		: virtual public basic_ios<charT,traits>
	{
	public:

		typedef charT char_type;
		typedef typename traits::int_type int_type;
		typedef typename traits::pos_type pos_type;
		typedef typename traits::off_type off_type;
		typedef traits traits_type;


		_UCXXEXPORT basic_ostream(basic_streambuf<charT,traits>* sb)
			: basic_ios<charT, traits>(sb)
		{
			basic_ios<charT,traits>::init(sb);
		}
		virtual _UCXXEXPORT ~basic_ostream();

		class sentry;

		_UCXXEXPORT basic_ostream<charT,traits>& operator<<(basic_ostream<charT,traits>& (*pf)(basic_ostream<charT,traits>&)){
			return pf(*this);
		}
		_UCXXEXPORT basic_ostream<charT,traits>& operator<<(basic_ios<charT,traits>& (*pf)(basic_ios<charT,traits>&)){
			pf(*this);
			return *this;
		}
		_UCXXEXPORT basic_ostream<charT,traits>& operator<<(ios_base& (*pf)(ios_base&)){
			pf(*this);
			return *this;
		}
		basic_ostream<charT,traits>& operator<<(bool n);
		basic_ostream<charT,traits>& operator<<(short n);
		basic_ostream<charT,traits>& operator<<(unsigned short n);
		basic_ostream<charT,traits>& operator<<(int n);
		basic_ostream<charT,traits>& operator<<(unsigned int n);
		basic_ostream<charT,traits>& operator<<(long n);
		basic_ostream<charT,traits>& operator<<(unsigned long n);
		basic_ostream<charT,traits>& operator<<(float f);
		basic_ostream<charT,traits>& operator<<(double f);
		basic_ostream<charT,traits>& operator<<(long double f);
		basic_ostream<charT,traits>& operator<<(void* p);
		basic_ostream<charT,traits>& operator<<(basic_streambuf<char_type,traits>* sb);
#if defined( __AVR__ )
		basic_ostream<charT,traits>& operator<<(const __FlashStringHelper* p);
#endif

		_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){
			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;
	}
#if defined( __AVR__ )
	template <class charT, class traits> _UCXXEXPORT basic_ostream<charT,traits>& basic_ostream<charT, traits>::operator<<(const __FlashStringHelper* p ){
		sentry s(*this);
		char buffer[64];
		size_t p_len = strlcpy_P(buffer,reinterpret_cast<const char*>(p),sizeof(buffer));
		printout(buffer, (p_len>=sizeof(buffer)) ? sizeof(buffer) - 1 : p_len ); 
		if(basic_ios<charT,traits>::flags() & ios_base::unitbuf){
			flush();
		}
		return *this;
	}
#endif


	/*Template Specializations*/

#ifdef __UCLIBCXX_EXPAND_OSTREAM_CHAR__
#ifndef __UCLIBCXX_COMPILE_OSTREAM__

#ifdef __UCLIBCXX_EXPAND_CONSTRUCTORS_DESTRUCTORS__

	template <> _UCXXEXPORT ostream::~basic_ostream();

#endif // __UCLIBCXX_EXPAND_CONSTRUCTORS_DESTRUCTORS__

	template <> _UCXXEXPORT ostream & ostream::flush();

	template <> _UCXXEXPORT ostream & ostream::operator<<(bool n);
	template <> _UCXXEXPORT ostream & ostream::operator<<(short int n);
	template <> _UCXXEXPORT ostream & ostream::operator<<(unsigned short int n);
	template <> _UCXXEXPORT ostream & ostream::operator<<(int n);
	template <> _UCXXEXPORT ostream & ostream::operator<<(unsigned int n);
	template <> _UCXXEXPORT ostream & ostream::operator<<(long n);
	template <> _UCXXEXPORT ostream & ostream::operator<<(unsigned long n);
	template <> _UCXXEXPORT ostream & ostream::operator<<(float f);
	template <> _UCXXEXPORT ostream & ostream::operator<<(double f);
	template <> _UCXXEXPORT ostream & ostream::operator<<(long double f);
	template <> _UCXXEXPORT ostream & ostream::operator<<(void* p);
	template <> _UCXXEXPORT ostream & ostream::operator<<(basic_streambuf<char, char_traits<char> >* sb);
#endif
#endif

	template <class charT,class traits = char_traits<charT> >
		class _UCXXEXPORT basic_ostream<charT,traits>::sentry
	{
		bool ok;
	public:
		explicit _UCXXEXPORT sentry(basic_ostream<charT,traits>& os): ok(true){
			if(os.good() !=0){		//Prepare for output
			}

			//Flush any tied buffer
			if(os.tie() !=0 ){
				os.tie()->flush();
			}
		}
		_UCXXEXPORT ~sentry() { }
		_UCXXEXPORT operator bool() {
			return ok;
		}
	};


#ifdef __UCLIBCXX_EXPAND_OSTREAM_CHAR__
#ifndef __UCLIBCXX_COMPILE_OSTREAM__
#ifdef __UCLIBCXX_EXPAND_CONSTRUCTORS_DESTRUCTORS__

	template <> _UCXXEXPORT ostream::sentry::sentry(ostream & os);
	template <> _UCXXEXPORT ostream::sentry::~sentry();

#endif //__UCLIBCXX_EXPAND_CONSTRUCTORS_DESTRUCTORS__
#endif
#endif


	//Non - class functions


	template<class charT, class traits> _UCXXEXPORT basic_ostream<charT,traits>&
		operator<<(basic_ostream<charT,traits>& out, charT c)
	{
		typename basic_ostream<charT,traits>::sentry s(out);
		out.put(c);
		return out;
	}
	
	template<class charT, class traits> _UCXXEXPORT basic_ostream<charT,traits>&
		operator<<(basic_ostream<charT,traits>& out, char c)
	{
		typename basic_ostream<charT,traits>::sentry s(out);
		out.put(c);
		return out;
	}
    
	template<class traits> _UCXXEXPORT basic_ostream<char,traits>&
		operator<<(basic_ostream<char,traits>& out, char c)
	{
		typename basic_ostream<char,traits>::sentry s(out);
		out.put(c);
		return out;
	}
    
    // signed and unsigned
	template<class traits> _UCXXEXPORT basic_ostream<char,traits>&
		operator<<(basic_ostream<char,traits>& out, signed char c)
	{
		typename basic_ostream<char,traits>::sentry s(out);
		out.put(c);
		return out;
	}
	
	template<class traits> _UCXXEXPORT basic_ostream<char,traits>&
		operator<<(basic_ostream<char,traits>& out, unsigned char c)
	{
		typename basic_ostream<char,traits>::sentry s(out);
		out.put(c);
		return out;
	}
	
	template<class charT, class traits> _UCXXEXPORT basic_ostream<charT,traits>&
		operator<<(basic_ostream<charT,traits>& out, const charT* c)
	{
		typename basic_ostream<charT,traits>::sentry s(out);
		out.printout(c, traits::length(c) );
		return out;
	}
	
	template<class charT, class traits> _UCXXEXPORT basic_ostream<charT,traits>&
		operator<<(basic_ostream<charT,traits>& out, const char* c)
	{
		typename basic_ostream<charT,traits>::sentry s(out);
		out.printout(c, char_traits<char>::length(c) );
		return out;
	}

    // 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;
	}
#endif
    
    //  signed and unsigned
	template<class traits> _UCXXEXPORT basic_ostream<char,traits>&
		operator<<(basic_ostream<char,traits>& out, const signed char* c)
	{
		typename basic_ostream<char,traits>::sentry s(out);
		out.printout(reinterpret_cast<const char *>(c), traits::length( reinterpret_cast<const char *>(c)));
		return out;
	}
	
	template<class traits> _UCXXEXPORT basic_ostream<char,traits>&
		operator<<(basic_ostream<char,traits>& out, const unsigned char* c)
	{
		typename basic_ostream<char,traits>::sentry s(out);
		out.printout(reinterpret_cast<const char *>(c), traits::length( reinterpret_cast<const char *>(c)));
		return out;
	}

	template <class charT, class traits> _UCXXEXPORT basic_ostream<charT,traits>&
		endl(basic_ostream<charT,traits>& os)
	{
		typename basic_ostream<charT,traits>::sentry s(os);
		os.put('\n');
		os.flush();
		return os;
	}

	template <class charT, class traits> _UCXXEXPORT basic_ostream<charT,traits>&
		ends(basic_ostream<charT,traits>& os)
	{
		typename basic_ostream<charT,traits>::sentry s(os);
		os.put(traits::eos());
		return os;
	}

	template <class charT, class traits> _UCXXEXPORT basic_ostream<charT,traits>& flush(basic_ostream<charT,traits>& os){
		typename basic_ostream<charT,traits>::sentry s(os);
		os.flush();
		return os;
	}


#ifdef __UCLIBCXX_EXPAND_OSTREAM_CHAR__
#ifndef __UCLIBCXX_COMPILE_OSTREAM__
	template <> _UCXXEXPORT ostream & endl(ostream & os);
	template <> _UCXXEXPORT ostream & flush(ostream & os);
	template <> _UCXXEXPORT ostream & operator<<(ostream & out, char c);
	template <> _UCXXEXPORT ostream & operator<<(ostream & out, const char* c);
	template <> _UCXXEXPORT ostream & operator<<(ostream & out, unsigned char c);
	template <> _UCXXEXPORT ostream & operator<<(ostream & out, unsigned const char* c);

#endif
#endif


#ifndef __STRICT_ANSI__

//Support for output of long long data types

template<class Ch, class Tr> _UCXXEXPORT basic_ostream<Ch, Tr>& 
	operator<<(basic_ostream<Ch, Tr>& os, signed long long int i)
{
	typename basic_ostream<Ch, Tr>::sentry s(os);
	__ostream_printout<Tr, Ch, signed long long int>::printout(os, i);
	return os;
}


template<class Ch, class Tr> _UCXXEXPORT basic_ostream<Ch, Tr>& 
	operator<<(basic_ostream<Ch, Tr>& os, unsigned long long int i)
{
	typename basic_ostream<Ch, Tr>::sentry s(os);
	__ostream_printout<Tr, Ch, unsigned long long int>::printout(os, i);
	return os;
}


#endif	//__STRICT_ANSI__




}

#pragma GCC visibility pop

#endif


57 by edam added ulibc	1	/* Copyright (C) 2004-2008 Garrett A. Kajmowicz
	2
	3	This file is part of the uClibc++ Library.
	4
	5	This library is free software; you can redistribute it and/or
	6	modify it under the terms of the GNU Lesser General Public
	7	License as published by the Free Software Foundation; either
	8	version 2.1 of the License, or (at your option) any later version.
	9
	10	This library is distributed in the hope that it will be useful,
	11	but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	13	Lesser General Public License for more details.
	14
	15	You should have received a copy of the GNU Lesser General Public
	16	License along with this library; if not, write to the Free Software
	17	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	18	*/
	19
	20	#include <basic_definitions>
	21
	22	#ifndef STD_HEADER_OSTREAM
	23	#define STD_HEADER_OSTREAM 1
	24
	25	#include <iosfwd>
	26	#include <streambuf>
	27	#include <cstdio>
	28	#include <ostream_helpers>
	29
	30	#if defined( __AVR__ )
	31	#include <avr/pgmspace.h>
	32	class __FlashStringHelper;
	33	#endif
	34
	35	#pragma GCC visibility push(default)
	36
	37	namespace std {
	38	template <class charT, class traits > class basic_ostream;
	39	typedef basic_ostream<char> ostream;
	40
	41	#ifdef __UCLIBCXX_HAS_WCHAR__
	42	typedef basic_ostream<wchar_t> wostream;
	43	#endif
	44
	45	template <class charT, class traits> basic_ostream<charT,traits>& endl(basic_ostream<charT,traits>& os);
	46	template <class charT, class traits> basic_ostream<charT,traits>& ends(basic_ostream<charT,traits>& os);
	47	template <class charT, class traits> basic_ostream<charT,traits>& flush(basic_ostream<charT,traits>& os);
	48
	49	template <class charT, class traits > class _UCXXEXPORT basic_ostream
	50	: virtual public basic_ios<charT,traits>
	51	{
	52	public:
	53
	54	typedef charT char_type;
	55	typedef typename traits::int_type int_type;
	56	typedef typename traits::pos_type pos_type;
	57	typedef typename traits::off_type off_type;
	58	typedef traits traits_type;
	59
	60
	61	_UCXXEXPORT basic_ostream(basic_streambuf<charT,traits>* sb)
	62	: basic_ios<charT, traits>(sb)
	63	{
	64	basic_ios<charT,traits>::init(sb);
65	}
66	virtual _UCXXEXPORT ~basic_ostream();
67
68	class sentry;
69
70	_UCXXEXPORT basic_ostream<charT,traits>& operator<<(basic_ostream<charT,traits>& (*pf)(basic_ostream<charT,traits>&)){
71	return pf(*this);
72	}
73	_UCXXEXPORT basic_ostream<charT,traits>& operator<<(basic_ios<charT,traits>& (*pf)(basic_ios<charT,traits>&)){
74	pf(*this);
75	return *this;
76	}
77	_UCXXEXPORT basic_ostream<charT,traits>& operator<<(ios_base& (*pf)(ios_base&)){
78	pf(*this);
79	return *this;
80	}
81	basic_ostream<charT,traits>& operator<<(bool n);
82	basic_ostream<charT,traits>& operator<<(short n);
83	basic_ostream<charT,traits>& operator<<(unsigned short n);
84	basic_ostream<charT,traits>& operator<<(int n);
85	basic_ostream<charT,traits>& operator<<(unsigned int n);
86	basic_ostream<charT,traits>& operator<<(long n);
87	basic_ostream<charT,traits>& operator<<(unsigned long n);
88	basic_ostream<charT,traits>& operator<<(float f);
89	basic_ostream<charT,traits>& operator<<(double f);
90	basic_ostream<charT,traits>& operator<<(long double f);
91	basic_ostream<charT,traits>& operator<<(void* p);
92	basic_ostream<charT,traits>& operator<<(basic_streambuf<char_type,traits>* sb);
93	#if defined( __AVR__ )
94	basic_ostream<charT,traits>& operator<<(const __FlashStringHelper* p);
95	#endif
96
97	_UCXXEXPORT basic_ostream<charT,traits>& put(char_type c){
98	if(basic_ostream<charT,traits>::traits_type::eq_int_type(
99	basic_ios<charT, traits>::mstreambuf->sputc(c),
100	basic_ostream<charT,traits>::traits_type::eof()))
101	{
102	basic_ios<charT,traits>::setstate(ios_base::eofbit);
103	}
104	return *this;
105	}
106	_UCXXEXPORT basic_ostream<charT,traits>& write(const char_type* s, streamsize n){
107	if(basic_ostream<charT,traits>::traits_type::eq_int_type(
108	basic_ios<charT, traits>::mstreambuf->sputn(s, n),
109	basic_ostream<charT,traits>::traits_type::eof())
110	){
111	basic_ios<charT,traits>::setstate(ios_base::eofbit);
112	}
113	return *this;
114	}
115	_UCXXEXPORT basic_ostream<charT,traits>& flush(){
116	if(basic_ios<charT, traits>::mstreambuf->pubsync() == -1){
117	basic_ios<charT,traits>::setstate(ios_base::badbit);
118	}
119	return *this;
120	}
121	_UCXXEXPORT pos_type tellp(){
122	if(basic_ios<charT,traits>::fail() != false){
123	return pos_type(-1);
124	}
125	return basic_ios<charT,traits>::rdbuf()->pubseekoff(0, ios_base::cur, ios_base::out);
126	}
127	_UCXXEXPORT basic_ostream<charT,traits>& seekp(pos_type pos){
128	if( basic_ios<charT,traits>::fail() != true ){
129	basic_ios<charT,traits>::rdbuf()->pubseekpos(pos);
130	}
131	return *this;
132	}
133	_UCXXEXPORT basic_ostream<charT,traits>& seekp(off_type off, ios_base::seekdir dir){
134	if( basic_ios<charT,traits>::fail() != true){
135	basic_ios<charT,traits>::rdbuf()->pubseekoff(off, dir);
136	}
137	return *this;
138	}
139
140	_UCXXEXPORT void printout(const char_type* s, streamsize n){
141	streamsize extra = ios::width() - n;
142	if ((ios::flags()&ios::adjustfield) == ios::right){
143	while (extra > 0) {
144	--extra;
145	put(ios::fill());
146	}
147	}
148	write(s, n);
149	if ((ios::flags()&ios::adjustfield) == ios::left) {
150	while (extra > 0) {
151	--extra;
152	put(ios::fill());
153	}
154	}
155	// Width value only applies for the next output operation. Reset to zero.
156	ios::width(0);
157	}
158
159	protected:
160	basic_ostream(const basic_ostream<charT,traits> &){ }
161	basic_ostream<charT,traits> & operator=(const basic_ostream<charT,traits> &){ return *this; }
162	};
163
164	//Implementations of template functions. To allow for partial specialization
165
166	template <class charT, class traits> _UCXXEXPORT basic_ostream<charT,traits>::~basic_ostream(){ }
167
168	template <class charT, class traits> _UCXXEXPORT basic_ostream<charT,traits>& basic_ostream<charT, traits>::operator<<(bool n){
169	sentry s(*this);
170	if( basic_ios<charT,traits>::flags() & ios_base::boolalpha){
171	if(n){
172	printout("true", 4);
173	}else{
174	printout("false", 5);
175	}
176	}else{
177	if(n){
178	printout("1", 1);
179	}else{
180	printout("0", 1);
181	}
182	}
183	if(basic_ios<charT,traits>::flags() & ios_base::unitbuf){
184	flush();
185	}
186	return *this;
187	}
188
189	template <class charT, class traits> _UCXXEXPORT basic_ostream<charT,traits>&
190	basic_ostream<charT, traits>::operator<<(unsigned short n){
191	sentry s(*this);
192	__ostream_printout<traits, charT, unsigned long int>::printout(*this, n);
193	return *this;
194	}
195
196	template <class charT, class traits> _UCXXEXPORT basic_ostream<charT,traits>& basic_ostream<charT, traits>::operator<<(short n){
197	sentry s(*this);
198	__ostream_printout<traits, charT, long int>::printout(*this, n);
199	return *this;
200	}
201
202	template <class charT, class traits> _UCXXEXPORT basic_ostream<charT,traits>& basic_ostream<charT, traits>::operator<<(int n){
203	sentry s(*this);
204	__ostream_printout<traits, charT, long int>::printout(*this, n);
205	return *this;
206	}
207
208	template <class charT, class traits> _UCXXEXPORT basic_ostream<charT,traits>& basic_ostream<charT, traits>::operator<<(unsigned int n){
209	sentry s(*this);
210	__ostream_printout<traits, charT, unsigned long int>::printout(*this, n);
211	return *this;
212	}
213
214	template <class charT, class traits> _UCXXEXPORT basic_ostream<charT,traits>& basic_ostream<charT, traits>::operator<<(long n){
215	sentry s(*this);
216	__ostream_printout<traits, charT, long >::printout(*this, n);
217	return *this;
218	}
219
220	template <class charT, class traits> _UCXXEXPORT basic_ostream<charT,traits>&
221	basic_ostream<charT, traits>::operator<<(unsigned long n)
222	{
223	sentry s(*this);
224	__ostream_printout<traits, charT, unsigned long >::printout(*this, n);
225	return *this;
226	}
227
228	template <class charT, class traits> _UCXXEXPORT basic_ostream<charT,traits>& basic_ostream<charT, traits>::operator<<(float f){
229	sentry s(*this);
230	__ostream_printout<traits, charT, double >::printout(*this, f);
231	return *this;
232	}
233
234	template <class charT, class traits> _UCXXEXPORT basic_ostream<charT,traits>& basic_ostream<charT, traits>::operator<<(double f){
235	sentry s(*this);
236	__ostream_printout<traits, charT, double >::printout(*this, f);
237	return *this;
238	}
239
240	template <class charT, class traits> _UCXXEXPORT basic_ostream<charT,traits>& basic_ostream<charT, traits>::operator<<(long double f){
241	sentry s(*this);
242	__ostream_printout<traits, charT, long double >::printout(*this, f);
243	return *this;
244	}
245
246	template <class charT, class traits> _UCXXEXPORT basic_ostream<charT,traits>& basic_ostream<charT, traits>::operator<<(void* p){
247	sentry s(*this);
248	char buffer[20];
249	printout(buffer, snprintf(buffer, 20, "%p", p) );
250	if(basic_ios<charT,traits>::flags() & ios_base::unitbuf){
251	flush();
252	}
253	return *this;
254	}
255	template <class charT, class traits> _UCXXEXPORT basic_ostream<charT,traits>&
256	basic_ostream<charT, traits>::operator<<(basic_streambuf<charT,traits>* sb)
257	{
258	sentry s(*this);
259	if(sb == 0){
260	basic_ios<charT,traits>::setstate(ios_base::badbit);
261	return *this;
262	}
263
264	typename traits::int_type c;
265
266	while(basic_ios<charT,traits>::good() && (c = sb->sbumpc()) != traits::eof() ){
267	put(c);
268	}
269
270	if(basic_ios<charT,traits>::flags() & ios_base::unitbuf){
271	flush();
272	}
273	return *this;
274	}
275	#if defined( __AVR__ )
276	template <class charT, class traits> _UCXXEXPORT basic_ostream<charT,traits>& basic_ostream<charT, traits>::operator<<(const __FlashStringHelper* p ){
277	sentry s(*this);
278	char buffer[64];
279	size_t p_len = strlcpy_P(buffer,reinterpret_cast<const char*>(p),sizeof(buffer));
280	printout(buffer, (p_len>=sizeof(buffer)) ? sizeof(buffer) - 1 : p_len );
281	if(basic_ios<charT,traits>::flags() & ios_base::unitbuf){
282	flush();
283	}
284	return *this;
285	}
286	#endif
287
288
289	/Template Specializations/
290
291	#ifdef __UCLIBCXX_EXPAND_OSTREAM_CHAR__
292	#ifndef __UCLIBCXX_COMPILE_OSTREAM__
293
294	#ifdef __UCLIBCXX_EXPAND_CONSTRUCTORS_DESTRUCTORS__
295
296	template <> _UCXXEXPORT ostream::~basic_ostream();
297
298	#endif // __UCLIBCXX_EXPAND_CONSTRUCTORS_DESTRUCTORS__
299
300	template <> _UCXXEXPORT ostream & ostream::flush();
301
302	template <> _UCXXEXPORT ostream & ostream::operator<<(bool n);
303	template <> _UCXXEXPORT ostream & ostream::operator<<(short int n);
304	template <> _UCXXEXPORT ostream & ostream::operator<<(unsigned short int n);
305	template <> _UCXXEXPORT ostream & ostream::operator<<(int n);
306	template <> _UCXXEXPORT ostream & ostream::operator<<(unsigned int n);
307	template <> _UCXXEXPORT ostream & ostream::operator<<(long n);
308	template <> _UCXXEXPORT ostream & ostream::operator<<(unsigned long n);
309	template <> _UCXXEXPORT ostream & ostream::operator<<(float f);
310	template <> _UCXXEXPORT ostream & ostream::operator<<(double f);
311	template <> _UCXXEXPORT ostream & ostream::operator<<(long double f);
312	template <> _UCXXEXPORT ostream & ostream::operator<<(void* p);
313	template <> _UCXXEXPORT ostream & ostream::operator<<(basic_streambuf<char, char_traits<char> >* sb);
314	#endif
315	#endif
316
317	template <class charT,class traits = char_traits<charT> >
318	class _UCXXEXPORT basic_ostream<charT,traits>::sentry
319	{
320	bool ok;
321	public:
322	explicit _UCXXEXPORT sentry(basic_ostream<charT,traits>& os): ok(true){
323	if(os.good() !=0){ //Prepare for output
324	}
325
326	//Flush any tied buffer
327	if(os.tie() !=0 ){
328	os.tie()->flush();
329	}
330	}
331	_UCXXEXPORT ~sentry() { }
332	_UCXXEXPORT operator bool() {
333	return ok;
334	}
335	};
336
337
338	#ifdef __UCLIBCXX_EXPAND_OSTREAM_CHAR__
339	#ifndef __UCLIBCXX_COMPILE_OSTREAM__
340	#ifdef __UCLIBCXX_EXPAND_CONSTRUCTORS_DESTRUCTORS__
341
342	template <> _UCXXEXPORT ostream::sentry::sentry(ostream & os);
343	template <> _UCXXEXPORT ostream::sentry::~sentry();
344
345	#endif //__UCLIBCXX_EXPAND_CONSTRUCTORS_DESTRUCTORS__
346	#endif
347	#endif
348
349
350	//Non - class functions
351
352
353	template<class charT, class traits> _UCXXEXPORT basic_ostream<charT,traits>&
354	operator<<(basic_ostream<charT,traits>& out, charT c)
355	{
356	typename basic_ostream<charT,traits>::sentry s(out);
357	out.put(c);
358	return out;
359	}
360
361	template<class charT, class traits> _UCXXEXPORT basic_ostream<charT,traits>&
362	operator<<(basic_ostream<charT,traits>& out, char c)
363	{
364	typename basic_ostream<charT,traits>::sentry s(out);
365	out.put(c);
366	return out;
367	}
368
369	template<class traits> _UCXXEXPORT basic_ostream<char,traits>&
370	operator<<(basic_ostream<char,traits>& out, char c)
371	{
372	typename basic_ostream<char,traits>::sentry s(out);
373	out.put(c);
374	return out;
375	}
376
377	// signed and unsigned
378	template<class traits> _UCXXEXPORT basic_ostream<char,traits>&
379	operator<<(basic_ostream<char,traits>& out, signed char c)
380	{
381	typename basic_ostream<char,traits>::sentry s(out);
382	out.put(c);
383	return out;
384	}
385
386	template<class traits> _UCXXEXPORT basic_ostream<char,traits>&
387	operator<<(basic_ostream<char,traits>& out, unsigned char c)
388	{
389	typename basic_ostream<char,traits>::sentry s(out);
390	out.put(c);
391	return out;
392	}
393
394	template<class charT, class traits> _UCXXEXPORT basic_ostream<charT,traits>&
395	operator<<(basic_ostream<charT,traits>& out, const charT* c)
396	{
397	typename basic_ostream<charT,traits>::sentry s(out);
398	out.printout(c, traits::length(c) );
399	return out;
400	}
401
402	template<class charT, class traits> _UCXXEXPORT basic_ostream<charT,traits>&
403	operator<<(basic_ostream<charT,traits>& out, const char* c)
404	{
405	typename basic_ostream<charT,traits>::sentry s(out);
406	out.printout(c, char_traits<char>::length(c) );
407	return out;
408	}
409
410	// partial specializations
411	template<class traits> _UCXXEXPORT basic_ostream<char,traits>&
412	operator<<(basic_ostream<char,traits>& out, const char* c)
413	{
414	typename basic_ostream<char,traits>::sentry s(out);
415	out.printout(c, traits::length(c));
416	return out;
417	}
418
419	#ifdef __UCLIBCXX_HAS_WCHAR__
420	template<class traits> _UCXXEXPORT basic_ostream<wchar_t,traits>&
421	operator<<(basic_ostream<wchar_t,traits>& out, const char* c)
422	{
423	typename basic_ostream<wchar_t, traits>::sentry s(out);
424	size_t numChars = char_traits<char>::length(c);
425	wchar_t * temp = new wchar_t[numChars];
426
427	for(size_t i=0; i < numChars; ++i){
428	temp[i] = out.widen(c[i]);
429	}
430
431	out.printout(temp, numChars);
432	return out;
433	}
434	#endif
435
436	// signed and unsigned
437	template<class traits> _UCXXEXPORT basic_ostream<char,traits>&
438	operator<<(basic_ostream<char,traits>& out, const signed char* c)
439	{
440	typename basic_ostream<char,traits>::sentry s(out);
441	out.printout(reinterpret_cast<const char >(c), traits::length( reinterpret_cast<const char >(c)));
442	return out;
443	}
444
445	template<class traits> _UCXXEXPORT basic_ostream<char,traits>&
446	operator<<(basic_ostream<char,traits>& out, const unsigned char* c)
447	{
448	typename basic_ostream<char,traits>::sentry s(out);
449	out.printout(reinterpret_cast<const char >(c), traits::length( reinterpret_cast<const char >(c)));
450	return out;
451	}
452
453	template <class charT, class traits> _UCXXEXPORT basic_ostream<charT,traits>&
454	endl(basic_ostream<charT,traits>& os)
455	{
456	typename basic_ostream<charT,traits>::sentry s(os);
457	os.put('\n');
458	os.flush();
459	return os;
460	}
461
462	template <class charT, class traits> _UCXXEXPORT basic_ostream<charT,traits>&
463	ends(basic_ostream<charT,traits>& os)
464	{
465	typename basic_ostream<charT,traits>::sentry s(os);
466	os.put(traits::eos());
467	return os;
468	}
469
470	template <class charT, class traits> _UCXXEXPORT basic_ostream<charT,traits>& flush(basic_ostream<charT,traits>& os){
471	typename basic_ostream<charT,traits>::sentry s(os);
472	os.flush();
473	return os;
474	}
475
476
477	#ifdef __UCLIBCXX_EXPAND_OSTREAM_CHAR__
478	#ifndef __UCLIBCXX_COMPILE_OSTREAM__
479	template <> _UCXXEXPORT ostream & endl(ostream & os);
480	template <> _UCXXEXPORT ostream & flush(ostream & os);
481	template <> _UCXXEXPORT ostream & operator<<(ostream & out, char c);
482	template <> _UCXXEXPORT ostream & operator<<(ostream & out, const char* c);
483	template <> _UCXXEXPORT ostream & operator<<(ostream & out, unsigned char c);
484	template <> _UCXXEXPORT ostream & operator<<(ostream & out, unsigned const char* c);
485
486	#endif
487	#endif
488
489
490	#ifndef __STRICT_ANSI__
491
492	//Support for output of long long data types
493
494	template<class Ch, class Tr> _UCXXEXPORT basic_ostream<Ch, Tr>&
495	operator<<(basic_ostream<Ch, Tr>& os, signed long long int i)
496	{
497	typename basic_ostream<Ch, Tr>::sentry s(os);
498	__ostream_printout<Tr, Ch, signed long long int>::printout(os, i);
499	return os;
500	}
501
502
503	template<class Ch, class Tr> _UCXXEXPORT basic_ostream<Ch, Tr>&
504	operator<<(basic_ostream<Ch, Tr>& os, unsigned long long int i)
505	{
506	typename basic_ostream<Ch, Tr>::sentry s(os);
507	__ostream_printout<Tr, Ch, unsigned long long int>::printout(os, i);
508	return os;
509	}
510
511
512	#endif //__STRICT_ANSI__
513
514
515
516
517	}
518
519	#pragma GCC visibility pop
520
521	#endif
522