ostream& ostream::operator<<(short n)
{
char obuffer[8]; // assumes max int is 65535
char fmt[4] = "%hd";
char leader[4] = "\0\0";
if (opfx())
{
if (n)
{
if (x_flags & (hex|oct))
{
if (x_flags & hex)
{
if (x_flags & uppercase)
fmt[2] = 'X';
else
fmt[2] = 'x';
leader[1] = fmt[2]; // 0x or 0X (or \0X)
}
else
fmt[2] = 'o';
if (x_flags & showbase)
leader[0] = '0';
}
else if ((n>0) && (x_flags & showpos))
{
leader[0] = '+';
}
}
sprintf(obuffer,fmt,n);
writepad(leader,obuffer);
osfx();
}
return *this;
}
ostream& ostream::operator<<(unsigned int n)
{
char obuffer[12];
char fmt[4] = "%u";
char leader[4] = "\0\0";
if (opfx())
{
if (n)
{
if (x_flags & (hex|oct))
{
if (x_flags & hex)
{
if (x_flags & uppercase)
fmt[1] = 'X';
else
fmt[1] = 'x';
leader[1] = fmt[1]; // 0x or 0X (or \0X)
}
else
fmt[1] = 'o';
if (x_flags & showbase)
leader[0] = '0';
}
else if (x_flags & showpos)
{
leader[0] = '+';
}
}
sprintf(obuffer,fmt,n);
writepad(leader,obuffer);
osfx();
}
return *this;
}
ostream& ostream::operator<<(long double f)
{
_WINSTATIC char obuffer[28];
_WINSTATIC char fmt[12];
_WINSTATIC char leader[4];
char * optr = obuffer;
int x = 0;
unsigned int curprecision = __min((unsigned)x_precision,LDBL_DIG);
if (opfx()) {
if (x_flags & ios::showpos)
leader[x++] = '+';
if (x_flags & ios::showpoint)
leader[x++] = '#'; // show decimal and trailing zeros
leader[x] = '\0';
x = sprintf(fmt,"%%%s.%.0uLg",leader,curprecision) - 1;
if ((x_flags & ios::floatfield)==ios::fixed)
fmt[x] = 'f';
else
{
if ((x_flags & ios::floatfield)==ios::scientific)
fmt[x] = 'e';
if (x_flags & uppercase)
fmt[x] = (char)toupper(fmt[x]);
}
sprintf(optr,fmt,f);
x = 0;
if (*optr=='+' || *optr=='-')
leader[x++] = *(optr++);
leader[x] = '\0';
writepad(leader,optr);
osfx();
}
return *this;
}
void ostream::outstr(const char *d, const char *p)
{
if( opfx() )
{
int plen = p ? strlen(p) : 0;
int dlen = d ? strlen(d) : 0;
int pad = width(0) - plen - dlen;
// pad on left (right-adjust) if needed -- the default case
if( ! (x_flags & (ios::left | ios::internal)) )
{
while( --pad >= 0 )
{
if( bp->sputc(x_fill) == EOF )
{
setstate(ios::badbit);
break;
}
}
}
// output the prefix
if( ! fail() && plen )
if( bp->sputn(p, plen) != plen )
setstate(ios::badbit);
// internal padding if needed
if( ! fail() && (x_flags & ios::internal) )
{
while( --pad >= 0 )
{
if( bp->sputc(x_fill) == EOF )
{
setstate(ios::badbit);
break;
}
}
}
// output the data
if( ! fail() && dlen )
if( bp->sputn(d, dlen) != dlen )
setstate(ios::badbit);
// pad on right (left-adjust) if needed
if( ! fail() && (x_flags & ios::left) )
{
while( --pad >= 0 )
{
if( bp->sputc(x_fill) == EOF )
{
setstate(ios::badbit);
break;
}
}
}
}
osfx();
}
ostream& ostream::operator<<(const char * s)
{
if (opfx())
{
writepad("",s);
osfx();
}
return *this;
}
ostream& ostream::put(unsigned char c)
{
if (opfx())
{
if (bp->sputc((int)c)==EOF)
state |= (failbit|badbit);
osfx();
}
return(*this);
}
ostream &ostream::operator << ( char const *s ) {
if( s != NULL ) {
__lock_it( __i_lock );
if( opfx() ) {
setstate( __WATCOM_ios::writeitem( *this, s, ::strlen( s ), 0 ) );
osfx();
}
}
return( *this );
}
ostream& ostream::write(const char * s, int n)
{
if (opfx())
{
// Note: 'n' treated as unsigned
if (bp->sputn(s,n)!=n)
state |= (failbit|badbit);
osfx();
}
return(*this);
}
ostream &ostream::write( char const *buf, int len ) {
/***************************************************/
// Write a sequence of characters to the ostream.
__lock_it( __i_lock );
if( opfx() ) {
if( len ) {
if( rdbuf()->sputn( buf, len ) != len ) {
setstate( ios::failbit );
}
}
osfx();
}
return( *this );
}
ostream& ostream::operator<<(streambuf * instm)
{
int c;
if (opfx())
{
while ((c=instm->sbumpc())!=EOF)
if (bp->sputc(c) == EOF)
{
state |= failbit;
break;
}
osfx();
}
return *this;
}
template <class STREAM> ACE_IOStream<STREAM> &
ACE_IOStream<STREAM>::operator<< (ACE_IOStream_String &v)
{
if (opfx ())
{
#if defined (ACE_WIN32) && defined (_MSC_VER)
for (int i = 0; i < v.GetLength (); ++i)
#else
for (u_int i = 0; i < (u_int) v.length (); ++i)
#endif /* ACE_WIN32 && defined (_MSC_VER) */
this->put (v[i]);
}
osfx ();
return *this;
}
ostream &ostream::operator << ( char c ) {
/****************************************/
// Write a single character to the stream.
__lock_it( __i_lock );
if( opfx() ) {
if( width() == 0 ) {
if( rdbuf()->sputc( c ) == EOF ) {
setstate( ios::failbit );
}
} else {
do_lshift( c );
}
osfx();
}
return( *this );
}
ostream& ostream::operator<<(const void * ptr)
{
char obuffer[12];
char fmt[4] = "%p";
char leader[4] = "0x";
if (opfx())
{
if (ptr)
{
if (x_flags & uppercase)
leader[1] = 'X';
}
sprintf(obuffer,fmt,ptr);
writepad(leader,obuffer);
osfx();
}
return *this;
}
ostream& ostream::operator<<(double f)
{
char obuffer[24];
char fmt[8];
char leader[4];
char * optr = obuffer;
int x = 0;
// x_floatused nonzero indicates called for float, not double
unsigned int curprecision = (x_floatused) ? FLT_DIG : DBL_DIG;
x_floatused = 0; // reset for next call
curprecision = __min((unsigned)x_precision,curprecision);
if (opfx())
{
if (x_flags & ios::showpos)
leader[x++] = '+';
if (x_flags & ios::showpoint)
leader[x++] = '#'; // show decimal and trailing zeros
leader[x] = '\0';
x = sprintf(fmt,"%%%s.%.0ug",leader,curprecision) - 1;
if ((x_flags & ios::floatfield)==ios::fixed)
fmt[x] = 'f';
else
{
if ((x_flags & ios::floatfield)==ios::scientific)
fmt[x] = 'e';
if (x_flags & uppercase)
fmt[x] = (char)toupper(fmt[x]);
}
sprintf(optr,fmt,f);
x = 0;
if (*optr=='+' || *optr=='-')
leader[x++] = *(optr++);
leader[x] = '\0';
writepad(leader,optr);
osfx();
}
return *this;
}
ostream& ostream::operator<<(unsigned char c)
{
if (opfx())
{
if (x_width)
{
char outc[2];
outc[0] = c;
outc[1] = '\0';
writepad("",outc);
}
else if (bp->sputc(c)==EOF)
{
if (bp->overflow(c)==EOF)
state |= (badbit|failbit); // fatal error?
}
osfx();
}
return *this;
}
ostream &ostream::operator << ( unsigned __int64 i ) {
/****************************************************/
// Write an unsigned 64bit integer to the stream.
// A signed 64bit integer displayed in base 8 or base 16 also uses
// this routine.
int base;
char buffer[LONGEST_INT64 + 1];
int size;
int digit_offset;
__lock_it( __i_lock );
base = __FlagsToBase( flags() );
// Sign:
if( i > 0 && (flags() & ios::showpos) && base == 10 ) {
buffer[0] = '+';
size = 1;
} else {
size = 0;
}
// Prefix:
__AddPrefix( i == 0, buffer, size, base, flags() );
// Digits:
digit_offset = size;
ulltoa( i, buffer + digit_offset, base );
if( flags() & ios::uppercase ) {
strupr( buffer );
}
size = ::strlen( buffer );
// Write the number:
if( opfx() ) {
setstate( __WATCOM_ios::writeitem( *this, buffer, size, digit_offset ) );
osfx();
}
return( *this );
}
ostream &ostream::operator << ( signed __int64 i ) {
/**************************************************/
// Write a signed long integer to the stream.
int base;
char buffer[LONGEST_INT64 + 1];
int size;
int digit_offset;
__lock_it( __i_lock );
base = __FlagsToBase( flags() );
if( base != 10 ) {
return( *this << (unsigned __int64) i );
}
// Sign:
if( i > 0 && (flags() & ios::showpos) ) {
buffer[0] = '+';
digit_offset = 1;
} else {
digit_offset = 0;
}
// Digits:
lltoa( i, buffer + digit_offset, base );
if( buffer[0] == '-' ) {
digit_offset = 1;
}
size = ::strlen( buffer );
// Write the number:
if( opfx() ) {
setstate( __WATCOM_ios::writeitem( *this, buffer, size, digit_offset ) );
osfx();
}
return( *this );
}
ostream &ostream::operator << ( unsigned long i ) {
int base;
char buffer[LONGEST_INTEGER + 1];
int size;
int digit_offset;
__lock_it( __i_lock );
base = __FlagsToBase( flags() );
// Sign:
if( i > 0 && (flags() & ios::showpos) && base == 10 ) {
buffer[0] = '+';
size = 1;
} else {
size = 0;
}
// Prefix:
__AddPrefix( i == 0, buffer, size, base, flags() );
// Digits:
digit_offset = size;
ultoa( i, buffer + digit_offset, base );
if( flags() & ios::uppercase ) {
strupr( buffer );
}
size = strlen( buffer );
// Write the number:
if( opfx() ) {
setstate( __WATCOM_ios::writeitem( *this, buffer, size, digit_offset ) );
osfx();
}
return( *this );
}
ostream &ostream::__outfloat( long double const &f ) {
/****************************************************/
// Write a "long double" floating-point value.
int digit_offset;
int precision;
char buf[LONGEST_FLOAT+1];
::memset( buf, 0, sizeof( buf ) );
__lock_it( __i_lock );
precision = this->precision();
if( precision > MAX_PREC ) precision = MAX_PREC;
__LDFloatToString( buf, (double const *)&f, precision, this->flags() );
if( buf[0] == '-' || buf[0] == '+' ) {
digit_offset = 1;
} else {
digit_offset = 0;
}
if( opfx() ) {
setstate( __WATCOM_ios::writeitem( *this, buf, ::strlen(buf), digit_offset ) );
osfx();
}
return( *this );
}
ostream &ostream::__outfloat( long double const &f ) {
int digit_offset;
int precision;
char buf[ LONGEST_FLOAT * 2 ];
long_double ld;
int i;
int len;
char *x;
CVT_INFO cvt;
auto char stkbuf[ LONGEST_FLOAT + 1 ];
std::ios::fmtflags format_flags;
#ifdef _LONG_DOUBLE_
double double_value;
/* convert this double into a long double */
double_value = f;
__EFG_cnvd2ld( &double_value, &ld );
#else
ld.value = f;
#endif
__lock_it( __i_lock );
precision = this->precision();
if( precision > MAX_PREC )
precision = MAX_PREC;
format_flags = this->flags();
if(( format_flags & ( std::ios::scientific | ios::fixed )) == std::ios::scientific ) {
cvt.flags = E_FMT;
cvt.scale = 1;
} else if(( format_flags & ( std::ios::scientific | ios::fixed )) == std::ios::fixed ) {
cvt.flags = F_FMT;
cvt.scale = 0;
} else {
cvt.flags = G_FMT;
cvt.scale = 1;
if( precision == 0 ) {
precision = 1;
}
}
if( format_flags & std::ios::showpoint ) {
cvt.flags |= F_DOT;
}
cvt.ndigits = precision;
cvt.expchar = ( format_flags & std::ios::uppercase ) ? 'E' : 'e';
cvt.expwidth = 0;
__EFG_cvtld( &ld, &cvt, stkbuf );
// put all the pieces together
len = cvt.n1 + cvt.nz1 + cvt.n2 + cvt.nz2 + 1;
if( cvt.sign < 0 ) {
++len;
} else if( format_flags & std::ios::showpos ) {
++len;
}
if( len > sizeof( buf ) ) {
x = new char[ len + 1 ];
} else {
x = buf;
}
i = 0;
digit_offset = 1;
if( cvt.sign < 0 ) {
x[i++] = '-';
} else if( format_flags & std::ios::showpos ) {
x[i++] = '+';
} else {
digit_offset = 0;
}
if( cvt.n1 != 0 ) {
::memcpy( &x[i], &stkbuf[0], cvt.n1 );
i += cvt.n1;
}
if( cvt.nz1 != 0 ) {
::memset( &x[i], '0', cvt.nz1 );
i += cvt.nz1;
}
if( cvt.n2 != 0 ) {
::memcpy( &x[i], &stkbuf[cvt.n1], cvt.n2 );
i += cvt.n2;
}
if( cvt.nz2 != 0 ) {
::memset( &x[i], '0', cvt.nz2 );
i += cvt.nz2;
}
x[i] = '\0';
if( opfx() ) {
setstate( __WATCOM_ios::writeitem( *this, x, ::strlen( x ), digit_offset ) );
osfx();
}
if( len > sizeof( buf ) ) {
delete x;
}
return( *this );
}
