MichaelAgarkov/CodeBlocksPortable
MichaelAgarkov/CodeBlocksPortable
Archived
1
1
Fork 0
Code Issues Pull requests Actions Packages Projects Releases Wiki Activity
This repository has been archived on 2024-12-16. You can view files and clone it, but cannot push or open issues or pull requests.
CodeBlocksPortable/Borland/BCC55/Include/ostream.h

628 lines
17 KiB
C
Raw Permalink Normal View History

My portable distribution of Code::Blocks
2024-07-04 16:52:56 +00:00
#ifndef __OSTREAM_H
#define __OSTREAM_H
#pragma option push -b -a8 -pc -Vx- -Ve- -w-inl -w-aus -w-sig
// -*- C++ -*-
#ifndef __STD_OSTREAM__
#define __STD_OSTREAM__
/***************************************************************************
*
* ostream - Declarations for the Standard Library ostream classes
*
***************************************************************************
*
* Copyright (c) 1994-1999 Rogue Wave Software, Inc. All Rights Reserved.
*
* This computer software is owned by Rogue Wave Software, Inc. and is
* protected by U.S. copyright laws and other laws and by international
* treaties. This computer software is furnished by Rogue Wave Software,
* Inc. pursuant to a written license agreement and may be used, copied,
* transmitted, and stored only in accordance with the terms of such
* license and with the inclusion of the above copyright notice. This
* computer software or any other copies thereof may not be provided or
* otherwise made available to any other person.
*
* U.S. Government Restricted Rights. This computer software is provided
* with Restricted Rights. Use, duplication, or disclosure by the
* Government is subject to restrictions as set forth in subparagraph (c)
* (1) (ii) of The Rights in Technical Data and Computer Software clause
* at DFARS 252.227-7013 or subparagraphs (c) (1) and (2) of the
* Commercial Computer Software <EFBFBD> Restricted Rights at 48 CFR 52.227-19,
* as applicable. Manufacturer is Rogue Wave Software, Inc., 5500
* Flatiron Parkway, Boulder, Colorado 80301 USA.
*
**************************************************************************/
#ifndef __STD_RWCOMPILER_H__
#include <stdcomp.h>
#endif
#ifdef _RW_STD_IOSTREAM
#include <ios>
#include <streambuf>
#ifndef _RWSTD_NO_NAMESPACE
namespace std {
#endif
extern ostream _RWSTDExport cout;
extern ostream _RWSTDExport cerr;
#ifndef _RWSTD_NO_WIDE_CHAR
extern wostream _RWSTDExport wcout;
extern wostream _RWSTDExport wcerr;
#endif
template <class charT, class traits>
inline bool __rw_is_out(basic_ostream<charT,traits>* s);
inline bool __rw_is_out(basic_ostream<char,char_traits<char> >* s);
#ifndef _RWSTD_NO_WIDE_CHAR
inline bool __rw_is_out(basic_ostream<wchar_t,char_traits<wchar_t> >* s);
#endif
template <class charT, class traits>
inline bool __rw_is_err(basic_ostream<charT,traits>* s);
inline bool __rw_is_err(basic_ostream<char,char_traits<char> >* s);
#ifndef _RWSTD_NO_WIDE_CHAR
inline bool __rw_is_err(basic_ostream<wchar_t,char_traits<wchar_t> >* s);
#endif
/*
* Class basic_ostream
*/
template<class charT, class traits>
class _RWSTDExportTemplate basic_ostream : virtual public basic_ios<charT, traits>
{
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;
typedef basic_ostream<charT, traits> ostream_type;
typedef basic_ios<charT, traits> ios_type;
_EXPLICIT basic_ostream(basic_streambuf<charT, traits> *sb);
#if defined ( __SUNPRO_CC )
_EXPLICIT basic_ostream(EmptyCtor) : basic_ios<charT, traits>(1) {}
#endif
virtual ~basic_ostream();
class sentry {
public:
inline _EXPLICIT
sentry(basic_ostream<charT,traits>& stream)
: __stream(stream)
{
#ifdef _RWSTD_MULTI_THREAD
if ( stream.rdbuf() ) {
__guard = new _RWSTDGuard(stream.rdbuf()->buffer_mutex_);
}
#ifndef _RWSTD_NO_EXCEPTIONS
try {
#endif
#endif // _RWSTD_MULTI_THREAD
if (stream.tie())
stream.tie()->flush();
if ( stream.is_synch() )
{
if ( __rw_is_out(&stream) )
{
fflush(stdout);
}
if ( __rw_is_err(&stream) )
{
fflush(stderr);
}
}
if ( stream.rdbuf() )
{
if ( stream.rdbuf()->which_open_mode( ) & ios_base::app )
stream.rdbuf()->pubseekoff(0,ios_base::end,ios_base::out);
}
ok_ = stream.good();
if ( !ok_ )
stream.setstate(ios_base::badbit);
#if defined (_RWSTD_MULTI_THREAD) && !defined (_RWSTD_NO_EXCEPTIONS)
} catch(...)
{
if ( __stream.rdbuf() )
delete __guard;
throw;
}
#endif // _RWSTD_MULTI_THREAD etc.
}
~sentry() {
if( __stream.flags() & ios_base::unitbuf)
{
if ( __stream.rdbuf()->pubsync() == -1 )
__stream.setstate(ios_base::badbit);
}
if ( __stream.is_synch() )
{
if ( __rw_is_out(&__stream) || __rw_is_err(&__stream) )
{
if ( __stream.rdbuf()->pubsync() == -1 )
__stream.setstate(ios_base::badbit);
}
}
#ifdef _RWSTD_MULTI_THREAD
if ( __stream.rdbuf() ) {
delete __guard;
}
#endif // _RWSTD_MULTI_THREAD
}
operator bool () const { return ok_; }
private:
sentry(const sentry&); // not defined
sentry& operator=(const sentry&); // not defined
basic_ostream<charT,traits>& __stream;
bool ok_;
#ifdef _RWSTD_MULTI_THREAD
_RWSTDGuard* __guard;
#endif
};
ostream_type& operator<<(ostream_type& (*pf)(ostream_type&));
ostream_type& operator<<(ios_base& (*pf)(ios_base&));
ostream_type& operator<<(ios_type& (*pf)(ios_type&));
#ifndef _RWSTD_NO_BOOL
ostream_type& operator<<(bool n);
#endif
ostream_type& operator<<(short n);
ostream_type& operator<<(unsigned short n);
ostream_type& operator<<(int n);
ostream_type& operator<<(unsigned int n);
ostream_type& operator<<(long n);
ostream_type& operator<<(unsigned long n);
ostream_type& operator<<(float f);
ostream_type& operator<<(double f);
ostream_type& operator<<(long double f);
#ifdef _RWSTD_LONG_LONG
ostream_type& operator<<(unsigned _RWSTD_LONG_LONG n);
ostream_type& operator<<(_RWSTD_LONG_LONG n);
#endif
ostream_type& operator<<(const void *p);
ostream_type& operator<<(basic_streambuf<char_type, traits>& sb)
{
ios_base::iostate err = 0;
#ifndef _RWSTD_NO_EXCEPTIONS
try {
#endif
if ( !(sb.which_open_mode() & ios_base::in) )
err = ios_base::failbit;
else
{
_TYPENAME basic_ostream<charT, traits>::sentry opfx(*this);
if(opfx)
{
if ( traits::eq_int_type(sb.sgetc(),traits::eof()))
err = ios_base::failbit;
else {
int_type c;
while( !traits::eq_int_type( (c = sb.sbumpc()),traits::eof()) )
{
if( traits::eq_int_type(this->rdbuf()->sputc(c),traits::eof()) )
{
err = ios_base::failbit;
break;
}
}
}
}
}
#ifndef _RWSTD_NO_EXCEPTIONS
}
#endif
#ifndef _RWSTD_NO_EXCEPTIONS
catch(...)
{
bool flag = false;
try {
this->setstate(ios_base::badbit);
}
catch( ios_base::failure ) { flag= true; }
if ( flag ) throw;
}
#endif
if ( err ) this->setstate(err);
return *this;
}
ostream_type& operator<<(basic_streambuf<char_type, traits> *sb)
{
ios_base::iostate err = 0;
#ifndef _RWSTD_NO_EXCEPTIONS
try {
#endif
if (sb)
{
if ( !(sb->which_open_mode() & ios_base::in) )
err = ios_base::failbit;
else
{
_TYPENAME basic_ostream<charT, traits>::sentry opfx(*this);
if(opfx)
{
if ( traits::eq_int_type(sb->sgetc(),traits::eof()))
err = ios_base::failbit;
else {
int_type c;
while( !traits::eq_int_type( (c = sb->sbumpc()),traits::eof()))
{
if( traits::eq_int_type(this->rdbuf()->sputc(c),traits::eof()))
{
err = ios_base::failbit;
break;
}
}
}
}
}
}
else
err = ios_base::badbit;
#ifndef _RWSTD_NO_EXCEPTIONS
}
#endif
#ifndef _RWSTD_NO_EXCEPTIONS
catch(...)
{
bool flag = false;
try {
this->setstate(ios_base::badbit);
}
catch( ios_base::failure ) { flag= true; }
if ( flag ) throw;
}
#endif
if ( err ) this->setstate(err);
return *this;
}
ostream_type& put(char_type c);
ostream_type& write(const char_type *s, streamsize n);
ostream_type& flush();
ostream_type& seekp(pos_type pos)
{
#ifdef _RWSTD_MULTI_THREAD
if ( this->rdbuf() ) {
# ifndef __TURBOC__
_RWSTDGuard guard(this->rdbuf()->buffer_mutex_);
# else
STDGUARD(this->rdbuf()->buffer_mutex_);
# endif // __TURBOC__
#endif // _RWSTD_MULTI_THREAD
if ( this->fail() ) return *this;
this->rdbuf()->pubseekpos(pos, ios_base::out);
#ifdef _RWSTD_MULTI_THREAD
}
#endif // _RWSTD_MULTI_THREAD
return *this; // RW_BUG: fix for bts-75631
}
ostream_type& seekp(off_type , ios_base::seekdir );
pos_type tellp();
#ifdef _RWSTD_MULTI_THREAD
_RWSTDGuard *ostream_sentry_guard;
#endif
protected:
basic_ostream();
#ifdef _RWSTD_PROTECTED_OSTREAM_COPY_CONSTRUCTOR
basic_ostream(const basic_ostream&);
#endif
};
inline bool __rw_is_out(basic_ostream<char,char_traits<char> >* s)
{ return (void*)s == (void*)&cout; }
#ifndef _RWSTD_NO_WIDE_CHAR
inline bool __rw_is_out(basic_ostream<wchar_t,char_traits<wchar_t> >* s)
{ return (void*)s == (void*)&wcout; }
#endif
inline bool __rw_is_err(basic_ostream<char,char_traits<char> >* s)
{ return (void*)s == (void*)&cerr; }
#ifndef _RWSTD_NO_WIDE_CHAR
inline bool __rw_is_err(basic_ostream<wchar_t,char_traits<wchar_t> >* s)
{ return (void*)s == (void*)&wcerr; }
#endif
template <class charT, class traits>
inline bool __rw_is_out(basic_ostream<charT,traits>* s)
{ return false; }
template <class charT, class traits>
inline bool __rw_is_err(basic_ostream<charT,traits>* s)
{ return false; }
//
// Class ostream_iterator
//
#if !defined(_MSC_VER) || defined(__BORLANDC__)
template <class T, class charT, class traits>
#else
template <class T, class charT=char, class traits=char_traits<charT> >
#endif
class _RWSTDExportTemplate ostream_iterator
: public iterator<output_iterator_tag,T,_TYPENAME traits::off_type,T*,T&>
{
protected:
basic_ostream<charT,traits>* __stream;
const charT* __str;
public:
//
//Types:
//
typedef T value_type;
typedef charT char_type;
typedef traits traits_type;
typedef basic_ostream<charT,traits> ostream_type;
ostream_iterator (basic_ostream<charT,traits>& s)
: __stream(&s),__str(0)
{ ; }
ostream_iterator (basic_ostream<charT,traits>& s,const charT* c)
: __stream(&s), __str((charT *)c)
{ ; }
ostream_iterator ( const ostream_iterator<T,charT,traits>& x )
: __stream(x.__stream) , __str(x.__str)
{ ; }
ostream_iterator<T,charT,traits>& operator= (const T& value)
{
*__stream << (T)value;
if (__str) *__stream << __str;
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; }
};
#ifndef _RWSTD_NO_COMPLEX_DEFAULT_TEMPLATES
typedef basic_ostream<char> ostream;
#else
typedef basic_ostream<char, char_traits<char> > ostream;
#endif
#ifndef _RWSTD_NO_WIDE_CHAR
#ifndef _RWSTD_NO_COMPLEX_DEFAULT_TEMPLATES
typedef basic_ostream<wchar_t> wostream;
#else
typedef basic_ostream<wchar_t, char_traits<wchar_t> > wostream;
#endif
#endif
// charT and charT* insertors
template<class charT, class traits>
basic_ostream<charT, traits>& _RWSTDExportTemplate operator<< ( basic_ostream<charT, traits>&,
charT );
#ifndef _RWSTD_NO_OVERLOAD_OF_TEMPLATE_FUNCTION
template<class charT, class traits>
basic_ostream<charT, traits>& _RWSTDExportTemplate operator<< ( basic_ostream<charT, traits>&,
char );
#ifndef _RWSTD_NO_FUNC_PARTIAL_SPEC
template <class traits>
basic_ostream<char, traits>& _RWSTDExportTemplate operator<< ( basic_ostream<char, traits>&,
char );
#else
ostream& _RWSTDExport operator<< ( ostream&, char );
#endif // _RWSTD_NO_FUNC_PARTIAL_SPEC
#endif // _RWSTD_NO_OVERLOAD_OF_TEMPLATE_FUNCTION
template<class charT, class traits>
basic_ostream<charT, traits>& _RWSTDExportTemplate operator<< ( basic_ostream<charT, traits>&,
const charT* );
#ifndef _RWSTD_NO_OVERLOAD_OF_TEMPLATE_FUNCTION
template<class charT, class traits>
basic_ostream<charT, traits>& _RWSTDExportTemplate operator<< ( basic_ostream<charT, traits>&,
const char* );
#ifndef _RWSTD_NO_FUNC_PARTIAL_SPEC
template <class traits>
basic_ostream<char, traits>& _RWSTDExportTemplate operator<< ( basic_ostream<char, traits>&,
const char* );
#else
ostream& _RWSTDExport operator<< ( ostream&, const char* );
#endif // _RWSTD_NO_FUNC_PARTIAL_SPEC
#endif // _RWSTD_NO_OVERLOAD_OF_TEMPLATE_FUNCTION
/*
* signed and unsigned insertors
*/
#ifndef _RWSTD_NO_SIGNED_CHAR_IN_STREAMS
template <class traits>
basic_ostream<char, traits>& _RWSTDExportTemplate operator<< ( basic_ostream<char, traits>&,
unsigned char );
template <class traits>
basic_ostream<char, traits>& _RWSTDExportTemplate operator<< ( basic_ostream<char, traits>&,
signed char );
template <class traits>
basic_ostream<char, traits>& _RWSTDExportTemplate operator<< ( basic_ostream<char, traits>&,
const unsigned char* );
template <class traits>
basic_ostream<char, traits>& _RWSTDExportTemplate operator<< ( basic_ostream<char, traits>&,
const signed char* );
#endif // _RWSTD_NO_SIGNED_CHAR_IN_STREAMS
/*
* String insertor
*/
template<class charT, class traits, class Allocator>
inline basic_ostream<charT, traits>&
operator<< (basic_ostream<charT,traits>& os,
const basic_string<charT,traits,Allocator>& s)
{
ios_base::iostate err = 0;
#ifndef _RWSTD_NO_EXCEPTIONS
try {
#endif
_TYPENAME basic_ostream<charT, traits>::sentry opfx(os);
if (opfx)
{
int dlen =s.length();
int pad = os.width() - dlen;
// place right padding
if( !(os.flags() & ios_base::adjustfield) || os.flags() & ios_base::right )
{
while(--pad >= 0)
{
if( traits::eq_int_type(os.rdbuf()->sputc(os.fill()),traits::eof())) {
err = ios_base::badbit;
break;
}
}
}
// output internal padding
if(os.good() && (os.flags() & ios_base::internal))
{
while(--pad >= 0)
{
if( traits::eq_int_type(os.rdbuf()->sputc(os.fill()),traits::eof()))
{
err = ios_base::badbit;
break;
}
}
}
if(os.good() && dlen) {
if(os.rdbuf() && (os.rdbuf()->sputn(s.c_str(), dlen) != dlen))
err = ios_base::badbit;
}
// output left padding.
if(os.good() && (os.flags() & ios_base::left))
{
while(--pad >= 0)
{
if( traits::eq_int_type(os.rdbuf()->sputc(os.fill()),traits::eof()))
{
err = ios_base::badbit;
break;
}
}
}
os.width(0);
}
#ifndef _RWSTD_NO_EXCEPTIONS
}
#endif
#ifndef _RWSTD_NO_EXCEPTIONS
catch(...)
{
bool flag = false;
try {
os.setstate(ios_base::badbit);
}
catch( ios_base::failure ) { flag= true; }
if ( flag ) throw;
}
#endif
if ( err ) os.setstate(err);
return os;
}
extern ostream _RWSTDExport cout;
extern ostream _RWSTDExport cerr;
extern ostream _RWSTDExport clog;
/*
* declare a couple of standard manipulators
* global functions
*/
template<class charT, class traits>
inline basic_ostream<charT, traits>&
endl(basic_ostream<charT, traits>& os)
{
os.put( charT('\n') );
os.flush();
return os;
}
template<class charT, class traits>
inline basic_ostream<charT, traits>&
ends(basic_ostream<charT, traits>& os)
{
os.put( charT(0) );
return os;
}
template<class charT, class traits>
inline basic_ostream<charT, traits>&
flush(basic_ostream<charT, traits>& os)
{
os.flush();
return os;
}
#ifndef _RWSTD_NO_NAMESPACE
}
#endif
#ifdef _RWSTD_COMPILE_INSTANTIATE
#include <ostream.cc>
#endif
#endif //_RW_STD_IOSTREAM
#endif //__STD_OSTREAM__
#ifndef __USING_STD_NAMES__
using namespace std;
#endif
#pragma option pop
#endif /* __OSTREAM_H */
Reference in a new issue Copy permalink