home *** CD-ROM | disk | FTP | other *** search
/ Chip 1997 October / Chip_1997-10_cd.bin / tema / sybase / powerj / h.z / IOSTREAM.H < prev    next >
C/C++ Source or Header  |  1996-11-07  |  22KB  |  740 lines
  1. //
  2. //  iostream.h    I/O streams
  3. //
  4. //  Copyright by WATCOM International Corp. 1988-1996.  All rights reserved.
  5. //
  6. #ifndef _IOSTREAM_H_INCLUDED
  7. #define _IOSTREAM_H_INCLUDED
  8. #if !defined(_ENABLE_AUTODEPEND)
  9.   #pragma read_only_file;
  10. #endif
  11.  
  12. #ifndef __cplusplus
  13. #error iostream.h is for use with C++
  14. #endif
  15. #ifndef _COMDEF_H_INCLUDED
  16.  #include <_comdef.h>
  17. #endif
  18.  
  19. #ifndef _WATCOM_EXCEPTION_DEFINED
  20. #define _WATCOM_EXCEPTION_DEFINED
  21. #define _WATCOM_EXCEPTION_DEFINED_
  22. struct __WATCOM_exception {
  23. #if defined(__AXP__) || defined(__PPC__)
  24.     void *__filler;
  25. #endif
  26. };
  27. #endif
  28.  
  29. // For multi-thread support.
  30. #ifndef __lock_it
  31.  
  32. class __lock;
  33.  
  34. #ifdef __SW_BM
  35. class _WPRTLINK __get_lock {
  36. public:
  37.     __get_lock( __lock * );
  38.     ~__get_lock();
  39. private:
  40.     __lock *__lk;
  41. };
  42. #define __lock_it( __l ) __get_lock __lock_name( __LINE__ )( __l )
  43. #define __lock_name( __ln ) __lock_glue( __lock__, __ln )
  44. #define __lock_glue( __pre, __lin ) __pre ## __lin
  45. #else 
  46. #define __lock_it( __l )
  47. #endif
  48. #endif
  49.  
  50. // Define EOF to be the same as that used with C, so that a user mixing
  51. // C and C++ won't get burned.
  52. #if !defined( EOF )
  53.     #define EOF (-1)
  54. #endif
  55.  
  56. // __NOT_EOF is useful for those functions that return "something other
  57. // than EOF" to indicate that everything is OK.
  58. #define __NOT_EOF 0
  59.  
  60. // Position in the stream (absolute value, 0 is first byte):
  61. typedef long streampos;
  62.  
  63. // Offset from current position in the stream:
  64. typedef long streamoff;
  65.  
  66. enum {
  67.     DEFAULT_PUTBACK_SIZE = 4,
  68.     DEFAULT_MAINBUF_SIZE = 512,
  69.     DEFAULT_BUF_SIZE     = DEFAULT_MAINBUF_SIZE + DEFAULT_PUTBACK_SIZE
  70. };
  71.  
  72. // These are referred to in class ios, but are defined later, or elsewhere:
  73. class _WPRTLINK __WATCOM_ios;
  74. class _WPRTLINK istream;
  75. class _WPRTLINK ostream;
  76. class _WPRTLINK streambuf;
  77.  
  78. // **************************** IOS ******************************************
  79. #if defined(_M_IX86)
  80.   #pragma pack(__push,1);
  81. #else
  82.   #pragma pack(__push,8);
  83. #endif
  84. class _WPRTLINK ios {
  85. public:
  86.     enum io_state {                     // Error state
  87.         goodbit = 0x00,                 // - no errors
  88.         badbit  = 0x01,                 // - operation failed, may not proceed
  89.         failbit = 0x02,                 // - operation failed, may proceed
  90.         eofbit  = 0x04                  // - end of file
  91.     };
  92.     typedef int iostate;
  93.     enum open_mode {                    // How to open a stream
  94.         in        = 0x0001,             // - open for input
  95.         out       = 0x0002,             // - open for output
  96.         atend     = 0x0004,             // - seek to end after opening
  97.         append    = 0x0008,             // - open for output, append to the end
  98.         truncate  = 0x0010,             // - discard contents after opening
  99.         nocreate  = 0x0020,             // - open only an existing file
  100.         noreplace = 0x0040,             // - open only a new file
  101.         text      = 0x0080,             // - open as text file
  102.         binary    = 0x0100,             // - open as binary file
  103.  
  104.         app       = append,             // Historical purposes
  105.         ate       = atend,
  106.         trunc     = truncate
  107.     };
  108.     typedef int openmode;
  109.     enum seek_dir {                     // Seek direction
  110.     beg      = 0x00,               // - seek from beginning
  111.     cur      = 0x01,               // - seek from current position
  112.         end       = 0x02                // - seek from end
  113.     };
  114.     typedef int seekdir;
  115.     enum fmt_flags {                    // Format flags
  116.         skipws     = 0x0001,            // - skip whitespace
  117.         left       = 0x0002,            // - align field to left edge
  118.         right      = 0x0004,            // - align field to right edge
  119.         internal   = 0x0008,            // - sign at left, value at right
  120.         dec        = 0x0010,            // - decimal conversion for integers
  121.         oct        = 0x0020,            // - octal conversion for integers
  122.         hex        = 0x0040,            // - hexadecimal conversion for integers
  123.         showbase   = 0x0080,            // - show dec/octal/hex base on output
  124.         showpoint  = 0x0100,            // - show decimal and digits on output
  125.         uppercase  = 0x0200,            // - use E,X (not e,x) on output numbers
  126.         showpos    = 0x0400,            // - use + for output positive numbers
  127.         scientific = 0x0800,            // - use scientific notation for output
  128.         fixed      = 0x1000,            // - use floating notation for output
  129.         unitbuf    = 0x2000,            // - flush stream after output
  130.         stdio      = 0x4000,            // - flush stdout/stderr after output
  131.  
  132.         #define _LAST_FORMAT_FLAG 0x00004000
  133.         #define _LAST_FLAG_BIT    0x80000000
  134.  
  135.         basefield  = dec | oct | hex,
  136.         adjustfield= left | right | internal,
  137.         floatfield = scientific | fixed,
  138.     };
  139.     typedef long fmtflags;
  140.  
  141.     class failure : public __WATCOM_exception {
  142.     iostate __cause;
  143.     public:
  144.     failure( iostate );        // - set the cause of failure
  145.     iostate cause() const;        // - query the cause of failure
  146.     };
  147.  
  148.     ios( streambuf *__sb );
  149.     ios( ios const & );
  150.     virtual ~ios();
  151.  
  152.     ios &operator = ( ios const & );
  153.         operator void * () const;
  154.     int operator !      () const;
  155.  
  156.     ostream   *tie( ostream *__ostrm );
  157.     ostream   *tie() const;
  158.     streambuf *rdbuf() const;
  159.     iostate    rdstate() const;
  160.     iostate    clear( iostate __state = 0 );
  161.     int        good() const;
  162.     int        bad()  const;
  163.     int        fail() const;
  164.     int        eof()  const;
  165.     iostate    exceptions( iostate __enable );
  166.     iostate    exceptions() const;
  167.     fmtflags   setf( fmtflags __onbits, fmtflags __mask );
  168.     fmtflags   setf( fmtflags __onbits );
  169.     fmtflags   unsetf( fmtflags __offbits );
  170.     fmtflags   flags( fmtflags __bits );
  171.     fmtflags   flags() const;
  172.     char       fill( char __fillchar );
  173.     char       fill() const;
  174.     int        precision( int __precision );
  175.     int        precision() const;
  176.     int        width( int __width );
  177.     int        width() const;
  178.     long      &iword( int __index );
  179.     void     *&pword( int __index );
  180.  
  181.     static void sync_with_stdio( void ) {};    // obsolete function
  182.  
  183.     static fmtflags bitalloc();
  184.     static int      xalloc();
  185.  
  186.     __lock *__i_lock;         // ios data member operations
  187.     static __lock *__x_lock; // xalloc/bitalloc operations
  188.  
  189. protected:
  190.     ios();
  191.  
  192.     void init( streambuf *__sb );
  193.     void setstate( ios::iostate __orbits );
  194.  
  195. private:
  196.     streambuf *__strmbuf;
  197.     ostream   *__tied_stream;
  198.     long       __format_flags;
  199.     int        __error_state;
  200.     int        __enabled_exceptions;
  201.     int        __float_precision;
  202.     int        __field_width;
  203.     void      *__xalloc_list;
  204.     char       __fill_character;
  205.  
  206.     static int       __xalloc_index;
  207.     static fmtflags  __last_format_flag;
  208.  
  209.     friend class __WATCOM_ios;
  210.     int : 0;
  211. };
  212. #pragma pack(__pop);
  213.  
  214. inline streambuf *ios::rdbuf() const {
  215.     return( __strmbuf );
  216. }
  217.  
  218. inline ios::iostate ios::rdstate() const {
  219.     return( __error_state );
  220. }
  221.  
  222. inline int ios::good() const {
  223.     return( __error_state == 0 );
  224. }
  225.  
  226. inline int ios::bad() const {
  227.     return( __error_state & ios::badbit );
  228. }
  229.  
  230. inline int ios::fail() const {
  231.     return( __error_state & (ios::failbit|ios::badbit) );
  232. }
  233.  
  234. inline int ios::eof() const {
  235.     return( __error_state & ios::eofbit );
  236. }
  237.  
  238. inline ios::iostate ios::exceptions() const {
  239.     return( __enabled_exceptions );
  240. }
  241.  
  242. inline ios::operator void * () const {
  243.     return( (void *) (fail()==0) );
  244. }
  245.  
  246. inline int ios::operator ! () const {
  247.     return( fail() );
  248. }
  249.  
  250. inline ios::fmtflags ios::setf( ios::fmtflags __onbits ) {
  251.     __lock_it( __i_lock );
  252.     ios::fmtflags __old_flags = __format_flags;
  253.     __format_flags           |= __onbits;
  254.     return( __old_flags );
  255. }
  256.  
  257. inline ios::fmtflags ios::setf( ios::fmtflags __onbits, ios::fmtflags __mask ) {
  258.     __lock_it( __i_lock );
  259.     ios::fmtflags __old_flags = __format_flags;
  260.     __format_flags           &= ~__mask;
  261.     __format_flags           |= __onbits & __mask;
  262.     return( __old_flags );
  263. }
  264.  
  265. inline ios::fmtflags ios::unsetf( ios::fmtflags __offbits ) {
  266.     __lock_it( __i_lock );
  267.     ios::fmtflags __old_flags = __format_flags;
  268.     __format_flags           &= ~__offbits;
  269.     return( __old_flags );
  270. }
  271.  
  272. inline ios::fmtflags ios::flags( ios::fmtflags __flags ) {
  273.     __lock_it( __i_lock );
  274.     ios::fmtflags __old_flags = __format_flags;
  275.     __format_flags            = __flags;
  276.     return( __old_flags );
  277. }
  278.  
  279. inline ios::fmtflags ios::flags() const {
  280.     return( __format_flags );
  281. }
  282.  
  283. inline char ios::fill( char __fillchar ) {
  284.     __lock_it( __i_lock );
  285.     char __old_fill  = __fill_character;
  286.     __fill_character = __fillchar;
  287.     return( __old_fill );
  288. }
  289.  
  290. inline char ios::fill() const {
  291.     return( __fill_character );
  292. }
  293.  
  294. inline int ios::precision( int __precision ) {
  295.     __lock_it( __i_lock );
  296.     int __old_precision = __float_precision;
  297.     __float_precision   = __precision;
  298.     return( __old_precision );
  299. }
  300.  
  301. inline int ios::precision() const {
  302.     return( __float_precision );
  303. }
  304.  
  305. inline int ios::width( int __width ) {
  306.     __lock_it( __i_lock );
  307.     int __old_width = __field_width;
  308.     __field_width   = __width;
  309.     return( __old_width );
  310. }
  311.  
  312. inline int ios::width() const {
  313.     return( __field_width );
  314. }
  315.  
  316. inline ostream *ios::tie( ostream *__ostrm ) {
  317.     __lock_it( __i_lock );
  318.     ostream *__old_tie = __tied_stream;
  319.     __tied_stream      = __ostrm;
  320.     return( __old_tie );
  321. }
  322.  
  323. inline ostream *ios::tie() const {
  324.     return( __tied_stream );
  325. }
  326.  
  327. // **************************** STREAMBUF ************************************
  328. // For compatibility with other vendors who include "streambuf" in IOSTREAM.H
  329. #ifndef _STREAMBUF_H_INCLUDED
  330.  #include <streambu.h>
  331. #endif
  332.  
  333. // **************************** ISTREAM **************************************
  334. #if defined(_M_IX86)
  335.   #pragma pack(__push,1);
  336. #else
  337.   #pragma pack(__push,8);
  338. #endif
  339. class _WPRTLINK istream : virtual public ios {
  340. public:
  341.     istream( streambuf *__sb );
  342.     istream( istream const &__istrm );
  343.     virtual ~istream();
  344.  
  345.     istream &operator = ( streambuf * __sb );
  346.     istream &operator = ( istream const &__istrm );
  347.     istream &operator >> (             char * __buf );
  348.     istream &operator >> (      signed char * __buf );
  349.     istream &operator >> (    unsigned char * __buf );
  350.     istream &operator >> (             char & __c );
  351.     istream &operator >> (      signed char & __c );
  352.     istream &operator >> (    unsigned char & __c );
  353.     istream &operator >> (     signed short & __i );
  354.     istream &operator >> (   unsigned short & __i );
  355.     istream &operator >> (       signed int & __i );
  356.     istream &operator >> (     unsigned int & __i );
  357.     istream &operator >> (      signed long & __i );
  358.     istream &operator >> (    unsigned long & __i );
  359.     istream &operator >> (   signed __int64 & __i );
  360.     istream &operator >> ( unsigned __int64 & __i );
  361.     istream &operator >> (            float & __f );
  362.     istream &operator >> (           double & __f );
  363.     istream &operator >> (      long double & __f );
  364.     istream &operator >> (        streambuf * __sb );
  365.     istream &operator >> ( ios &(*__f)( ios & ) );
  366.     istream &operator >> ( istream &(*__f)( istream & ) );
  367.  
  368.     int        ipfx( int __noskipws = 0 );
  369.     void       isfx();
  370.     int        get();
  371.     istream   &get(          char *__buf, int __len, char __delim = '\n' );
  372.     istream   &get(   signed char *__buf, int __len, char __delim = '\n' );
  373.     istream   &get( unsigned char *__buf, int __len, char __delim = '\n' );
  374.     istream   &get(          char &__c );
  375.     istream   &get(   signed char &__c );
  376.     istream   &get( unsigned char &__c );
  377.     istream   &get( streambuf &__sb, char __delim = '\n' );
  378.     istream   &getline(          char *__buf, int __len, char __delim = '\n' );
  379.     istream   &getline(   signed char *__buf, int __len, char __delim = '\n' );
  380.     istream   &getline( unsigned char *__buf, int __len, char __delim = '\n' );
  381.     istream   &ignore( int __num = 1, int __delim = EOF );
  382.     istream   &read(          char *__buf, int __len );
  383.     istream   &read(   signed char *__buf, int __len );
  384.     istream   &read( unsigned char *__buf, int __len );
  385.     istream   &seekg( streampos __position );
  386.     istream   &seekg( streamoff __offset, ios::seekdir __direction );
  387.     istream   &putback( char __c );
  388.     streampos  tellg();
  389.     int        gcount() const;
  390.     int        peek();
  391.     int        sync();
  392.  
  393. protected:
  394.     istream();
  395.     void     eatwhite();
  396.     istream &do_get( char &__c );
  397.     istream &do_rshift( char &__c );
  398.     istream &do_read( char *__buf, int __len );
  399.     int         ipfx0( void );
  400.     int         ipfx1( void );
  401.     int      do_ipfx( int __noskipws );
  402.  
  403. private:
  404.     int __last_read_length;
  405. };
  406. #pragma pack(__pop);
  407.  
  408. inline istream &istream::operator >> ( signed char *__buf ) {
  409.     return( *this >> (char *) __buf );
  410. }
  411.  
  412. inline istream &istream::operator >> ( unsigned char *__buf ) {
  413.     return( *this >> (char *) __buf );
  414. }
  415.  
  416. #ifdef __BIG_INLINE__
  417. inline istream &istream::operator >> ( char &__c ) {
  418.     __lock_it( __i_lock );
  419.     if( ipfx0() ) {
  420.         if( rdbuf()->in_avail() ) {
  421.         __c = (char)(rdbuf()->sgetchar());
  422.      } else {
  423.         do_rshift( __c );
  424.         }
  425.         isfx();
  426.     }
  427.     return( *this );
  428. }
  429. #endif
  430.  
  431. inline istream &istream::operator >> ( signed char &__c ) {
  432.     return( *this >> (char &) __c );
  433. }
  434.  
  435. inline istream &istream::operator >> ( unsigned char &__c ) {
  436.     return( *this >> (char &) __c );
  437. }
  438.  
  439. inline istream &istream::get( signed char *__buf, int __len, char __delim ) {
  440.     return( get( (char *)__buf, __len, __delim ) );
  441. }
  442.  
  443. inline istream &istream::get( unsigned char *__buf, int __len, char __delim ) {
  444.     return( get( (char *)__buf, __len, __delim ) );
  445. }
  446.  
  447. #ifdef __BIG_INLINE__
  448. inline istream &istream::get( char &__c ) {
  449.     __lock_it( __i_lock );
  450.     if( ipfx1() ) {
  451.         if( rdbuf()->in_avail() ) {
  452.         __c = (char)(rdbuf()->sgetchar());
  453.     } else {
  454.         do_get( __c );
  455.         }
  456.         isfx();
  457.     } else {
  458.     __last_read_length = 0;
  459.     }
  460.     return( *this );
  461. }
  462. #endif
  463.  
  464. inline istream &istream::get( signed char &__c ) {
  465.     return( get( (char &) __c ) );
  466. }
  467.  
  468. inline istream &istream::get( unsigned char &__c ) {
  469.     return( get( (char &) __c ) );
  470. }
  471.  
  472. inline istream &istream::getline( signed char *__buf, int __len,
  473.     char __delim ) {
  474.     return( getline( (char *)__buf, __len, __delim ) );
  475. }
  476.  
  477. inline istream &istream::getline( unsigned char *__buf, int __len,
  478.     char __delim ) {
  479.     return( getline( (char *)__buf, __len, __delim ) );
  480. }
  481.  
  482. #ifdef __BIG_INLINE__
  483. inline istream &istream::read( char *__buf, int __len ) {
  484.     __lock_it( __i_lock );
  485.     if( ipfx1() ) {
  486.         if( rdbuf()->in_avail() > __len ) {
  487.             __last_read_length = rdbuf()->sgetn( __buf, __len );
  488.         } else {
  489.         do_read( __buf , __len );
  490.     }
  491.         isfx();
  492.     } else {
  493.     __last_read_length = 0;
  494.     }
  495.     return( *this );
  496. }
  497. #endif
  498.  
  499. inline istream &istream::read( signed char *__buf, int __len ) {
  500.     return( read( (char *) __buf, __len ) );
  501. }
  502.  
  503. inline istream &istream::read( unsigned char *__buf, int __len ) {
  504.     return( read( (char *) __buf, __len ) );
  505. }
  506.  
  507. inline int istream::ipfx0( void ) {
  508.     __lock_it( __i_lock );
  509.     return( ((flags()&ios::skipws) || !good() || tie()) ? do_ipfx( 0 ) : 1);
  510. }
  511.  
  512. inline int istream::ipfx1( void ) {
  513.     __lock_it( __i_lock );
  514.     return( (!good() || tie()) ? do_ipfx( 1 ) : 1);
  515. }
  516.  
  517. inline void istream::isfx() {
  518. }
  519.  
  520. inline int istream::gcount() const {
  521.     return( __last_read_length );
  522. }
  523.  
  524. // **************************** OSTREAM **************************************
  525. #if defined(_M_IX86)
  526.   #pragma pack(__push,1);
  527. #else
  528.   #pragma pack(__push,8);
  529. #endif
  530. class _WPRTLINK ostream : virtual public ios {
  531. public:
  532.     ostream( streambuf *__sb );
  533.     ostream( ostream const &__ostrm );
  534.     virtual ~ostream();
  535.  
  536.     ostream &operator = ( streambuf *__sb );
  537.     ostream &operator = ( ostream const &__ostrm );
  538.     ostream &operator << (                char  __c );
  539.     ostream &operator << (         signed char  __c );
  540.     ostream &operator << (       unsigned char  __c );
  541.     ostream &operator << (        signed short  __s );
  542.     ostream &operator << (      unsigned short  __s );
  543.     ostream &operator << (          signed int  __i );
  544.     ostream &operator << (        unsigned int  __i );
  545.     ostream &operator << (         signed long  __l );
  546.     ostream &operator << (       unsigned long  __l );
  547.     ostream &operator << (      signed __int64  __l );
  548.     ostream &operator << (    unsigned __int64  __l );
  549.     ostream &operator << (               float  __f );
  550.     ostream &operator << (              double  __f );
  551.     ostream &operator << (         long double  __f );
  552.     ostream &operator << (                void *__p );
  553.     ostream &operator << (           streambuf *__sb );
  554.     ostream &operator << (          char const *__buf );
  555.     ostream &operator << (   signed char const *__buf );
  556.     ostream &operator << ( unsigned char const *__buf );
  557.     ostream &operator << ( ostream &(*__f)( ostream & ) );
  558.     ostream &operator << ( ios &(*__f)( ios & ) );
  559.  
  560.     int        opfx();
  561.     void       osfx();
  562.     ostream   &put(          char __c );
  563.     ostream   &put(   signed char __c );
  564.     ostream   &put( unsigned char __c );
  565.     ostream   &write(          char const *__buf, int __len );
  566.     ostream   &write(   signed char const *__buf, int __len );
  567.     ostream   &write( unsigned char const *__buf, int __len );
  568.     ostream   &flush();
  569.     ostream   &seekp( streampos __position );
  570.     ostream   &seekp( streamoff __offset, ios::seekdir __direction );
  571.     streampos  tellp();
  572.  
  573. protected:
  574.     ostream();
  575.     ostream &__outfloat( long double const & );
  576.     ostream &do_lshift( char __c);
  577.     int         do_opfx();
  578. };
  579. #pragma pack(__pop);
  580.  
  581. #ifdef __BIG_INLINE__
  582. inline ostream &ostream::operator << ( char __c ) {
  583.     __lock_it( __i_lock );
  584.     if( opfx() ) {
  585.     if( width() == 0 ) {
  586.         if( rdbuf()->sputc( __c ) == EOF ) {
  587.         setstate( ios::failbit );
  588.         }
  589.     } else {
  590.             do_lshift( __c );
  591.     }
  592.         osfx();
  593.     }
  594.     return( *this );
  595. }
  596. #endif
  597.  
  598. inline ostream &ostream::operator << ( signed char __c ) {
  599.     return( *this << (char) __c );
  600. }
  601.  
  602. inline ostream &ostream::operator << ( unsigned char __c ) {
  603.     return( *this << (char) __c );
  604. }
  605.  
  606. inline ostream &ostream::operator << ( signed short __s ) {
  607.     return( *this << (signed long) __s );
  608. }
  609.  
  610. inline ostream &ostream::operator << ( unsigned short __s ) {
  611.     return( *this << (unsigned long) __s );
  612. }
  613.  
  614. inline ostream &ostream::operator << ( signed int __i ) {
  615.     return( *this << (signed long) __i );
  616. }
  617.  
  618. inline ostream &ostream::operator << ( unsigned int __i ) {
  619.     return( *this << (unsigned long) __i );
  620. }
  621.  
  622. inline ostream &ostream::operator << ( float __f ) {
  623.     return( __outfloat( (long double)__f ) );
  624. }
  625.  
  626. inline ostream &ostream::operator << ( double __f ) {
  627.     return( __outfloat( (long double)__f ) );
  628. }
  629.  
  630. inline ostream &ostream::operator << ( long double __f ) {
  631.     return( __outfloat( __f ) );
  632. }
  633.  
  634. inline ostream &ostream::operator << ( signed char const *__buf ) {
  635.     return( *this << (char const *) __buf );
  636. }
  637.  
  638. inline ostream &ostream::operator << ( unsigned char const *__buf ) {
  639.     return( *this << (char const *) __buf );
  640. }
  641.  
  642. #ifdef __BIG_INLINE__
  643. inline ostream &ostream::put( char __c ) {
  644.     __lock_it( __i_lock );
  645.     if( opfx() ) {
  646.     if( rdbuf()->sputc( __c ) == EOF ) {
  647.         setstate( ios::failbit );
  648.     }
  649.     osfx();
  650.     }
  651.     return( *this );
  652. }
  653. #endif
  654.  
  655. inline ostream &ostream::put( signed char __c ) {
  656.     return( put( (char) __c ) );
  657. }
  658.  
  659. inline ostream &ostream::put( unsigned char __c ) {
  660.     return( put( (char) __c ) );
  661. }
  662.  
  663. #ifdef __BIG_INLINE__
  664. inline ostream &ostream::write( char const *__buf, int __len ) {
  665.     __lock_it( __i_lock );
  666.     if( opfx() ) {
  667.     if( __len  ) {
  668.         if( rdbuf()->sputn( __buf, __len ) != __len ) {
  669.         setstate( ios::failbit );
  670.         }
  671.     }
  672.     osfx();
  673.     }
  674.     return( *this );
  675. }
  676. #endif
  677.  
  678. inline ostream &ostream::write( signed char const *__buf, int __len ) {
  679.     return( write( (char const *) __buf, __len ) );
  680. }
  681.  
  682. inline ostream &ostream::write( unsigned char const *__buf, int __len ) {
  683.     return( write( (char const *) __buf, __len ) );
  684. }
  685.  
  686. inline int ostream::opfx() {
  687.     __lock_it( __i_lock );
  688.     if( !good() ) {
  689.         return 0;
  690.     } else if( tie() || ( flags() & ios::stdio ) ) {
  691.         return do_opfx();
  692.     } else {
  693.         return 1;
  694.     }
  695. }
  696.  
  697. inline void ostream::osfx() {
  698.     __lock_it( __i_lock );
  699.     if( flags() & ios::unitbuf ) {
  700.         flush();
  701.     }
  702. }
  703.  
  704. // **************************** IOSTREAM *************************************
  705. #if defined(_M_IX86)
  706.   #pragma pack(__push,1);
  707. #else
  708.   #pragma pack(__push,8);
  709. #endif
  710. class _WPRTLINK iostream : public istream, public ostream {
  711. public:
  712.     iostream( streambuf *__sb );
  713.     iostream( ios const &__strm );
  714.     virtual ~iostream();
  715.  
  716.     iostream & operator = ( streambuf *__sb );
  717.     iostream & operator = ( ios const &__strm );
  718.  
  719. protected:
  720.     iostream();
  721. };
  722. #pragma pack(__pop);
  723.  
  724. // **************************** MANIPULATORS *********************************
  725. _WPRTLINK extern ios &dec( ios & );
  726. _WPRTLINK extern ios &hex( ios & );
  727. _WPRTLINK extern ios &oct( ios & );
  728. _WPRTLINK extern istream &   ws( istream & );
  729. _WPRTLINK extern ostream & endl( ostream & );
  730. _WPRTLINK extern ostream & ends( ostream & );
  731. _WPRTLINK extern ostream &flush( ostream & );
  732.  
  733. // **************************** PREDEFINED STREAMS ***************************
  734.  _WPRTLINK extern istream _WCDATA cin;
  735.  _WPRTLINK extern ostream _WCDATA cout;
  736.  _WPRTLINK extern ostream _WCDATA cerr;
  737.  _WPRTLINK extern ostream _WCDATA clog;
  738.  
  739. #endif
  740.