home *** CD-ROM | disk | FTP | other *** search
/ PC Plus SuperCD (UK) 2000 May / PCP163A.iso / Runimage / Cbuilder4 / Include / OSTREAM.H < prev    next >
Encoding:
C/C++ Source or Header  |  1999-01-26  |  18.0 KB  |  626 lines
  1. #ifndef __OSTREAM_H
  2. #define __OSTREAM_H
  3. #pragma option push -b -a8 -pc -Vx- -Ve- -w-inl -w-aus -w-sig
  4. // -*- C++ -*-
  5. #ifndef __STD_OSTREAM__
  6. #define __STD_OSTREAM__
  7.  
  8. /***************************************************************************
  9.  *
  10.  * ostream - Declarations for the Standard Library ostream classes
  11.  *
  12.  ***************************************************************************
  13.  *
  14.  * (c) Copyright 1994, 1998 Rogue Wave Software, Inc.
  15.  * ALL RIGHTS RESERVED
  16.  *
  17.  * The software and information contained herein are proprietary to, and
  18.  * comprise valuable trade secrets of, Rogue Wave Software, Inc., which
  19.  * intends to preserve as trade secrets such software and information.
  20.  * This software is furnished pursuant to a written license agreement and
  21.  * may be used, copied, transmitted, and stored only in accordance with
  22.  * the terms of such license and with the inclusion of the above copyright
  23.  * notice.  This software and information or any other copies thereof may
  24.  * not be provided or otherwise made available to any other person.
  25.  *
  26.  * Notwithstanding any other lease or license that may pertain to, or
  27.  * accompany the delivery of, this computer software and information, the
  28.  * rights of the Government regarding its use, reproduction and disclosure
  29.  * are as set forth in Section 52.227-19 of the FARS Computer
  30.  * Software-Restricted Rights clause.
  31.  * 
  32.  * Use, duplication, or disclosure by the Government is subject to
  33.  * restrictions as set forth in subparagraph (c)(1)(ii) of the Rights in
  34.  * Technical Data and Computer Software clause at DFARS 252.227-7013.
  35.  * Contractor/Manufacturer is Rogue Wave Software, Inc.,
  36.  * P.O. Box 2328, Corvallis, Oregon 97339.
  37.  *
  38.  * This computer software and information is distributed with "restricted
  39.  * rights."  Use, duplication or disclosure is subject to restrictions as
  40.  * set forth in NASA FAR SUP 18-52.227-79 (April 1985) "Commercial
  41.  * Computer Software-Restricted Rights (April 1985)."  If the Clause at
  42.  * 18-52.227-74 "Rights in Data General" is specified in the contract,
  43.  * then the "Alternate III" clause applies.
  44.  *
  45.  **************************************************************************/
  46.  
  47. #ifndef __STD_RWCOMPILER_H__ 
  48. #include <stdcomp.h>
  49. #endif
  50.  
  51. #include <ios>
  52. #include <streambuf>
  53.  
  54. #ifndef _RWSTD_NO_NAMESPACE
  55. namespace std {
  56. #endif
  57.  
  58.   extern ostream _RWSTDExport cout;
  59.   extern ostream _RWSTDExport cerr;
  60.  
  61. #ifndef _RWSTD_NO_WIDE_CHAR
  62.   extern wostream _RWSTDExport wcout;
  63.   extern wostream _RWSTDExport wcerr;
  64. #endif
  65.  
  66. template <class charT, class traits>
  67. inline bool __rw_is_out(basic_ostream<charT,traits>* s);
  68. _RWSTD_TEMPLATE 
  69. inline bool __rw_is_out(basic_ostream<char,char_traits<char> >* s);
  70. #ifndef _RWSTD_NO_WIDE_CHAR
  71. _RWSTD_TEMPLATE 
  72. inline bool __rw_is_out(basic_ostream<wchar_t,char_traits<wchar_t> >* s);
  73. #endif
  74. template <class charT, class traits>
  75. inline bool __rw_is_err(basic_ostream<charT,traits>* s);
  76. _RWSTD_TEMPLATE 
  77. inline bool __rw_is_err(basic_ostream<char,char_traits<char> >* s);
  78. #ifndef _RWSTD_NO_WIDE_CHAR
  79. _RWSTD_TEMPLATE 
  80. inline bool __rw_is_err(basic_ostream<wchar_t,char_traits<wchar_t> >* s);
  81. #endif
  82.  
  83.   /*
  84.    *  Class basic_ostream
  85.    */
  86.  
  87.   template<class charT, class traits>
  88.   class _RWSTDExportTemplate basic_ostream : virtual public basic_ios<charT, traits>
  89.   {
  90.  
  91.   public:
  92.     //
  93.     // Types:
  94.     //
  95.     typedef charT                                  char_type;
  96.     typedef _TYPENAME traits::int_type             int_type;
  97.     typedef _TYPENAME traits::pos_type             pos_type;
  98.     typedef _TYPENAME traits::off_type             off_type;
  99.     typedef traits                                 traits_type;
  100.       
  101.     typedef basic_ostream<charT, traits>           ostream_type;
  102.     typedef basic_ios<charT, traits>               ios_type;
  103.  
  104.     _EXPLICIT basic_ostream(basic_streambuf<charT, traits> *sb);
  105.     virtual ~basic_ostream();
  106.  
  107.     class sentry {
  108.     public:
  109.  
  110.       inline _EXPLICIT
  111.       sentry(basic_ostream<charT,traits>& stream)
  112.         : __stream(stream)                  
  113.       {  
  114.                       
  115. #ifdef _RWSTD_MULTI_THREAD
  116.         if ( stream.rdbuf() )
  117.           stream.ostream_sentry_guard = new _RWSTDGuard(stream.rdbuf()->buffer_mutex_);
  118. #ifndef _RWSTD_NO_EXCEPTIONS
  119.         try {
  120. #endif
  121. #endif // _RWSTD_MULTI_THREAD
  122.           if (stream.tie()) 
  123.             stream.tie()->flush();
  124.  
  125.           if ( stream.is_synch() )
  126.           {
  127.             if ( __rw_is_out(&stream) )
  128.             {
  129.               fflush(stdout);
  130.             }
  131.             if ( __rw_is_err(&stream) )
  132.             {
  133.               fflush(stderr);
  134.             }
  135.           }
  136.  
  137.           if ( stream.rdbuf() )
  138.           {
  139.             if ( stream.rdbuf()->which_open_mode( ) & ios_base::app )
  140.               stream.rdbuf()->pubseekoff(0,ios_base::end,ios_base::out);
  141.           }
  142.  
  143.           ok_ = stream.good(); 
  144.  
  145.           if ( !ok_ ) 
  146.             stream.setstate(ios_base::badbit);
  147.  
  148. #if defined (_RWSTD_MULTI_THREAD) && !defined (_RWSTD_NO_EXCEPTIONS)
  149.         } catch(...) 
  150.         {
  151.           if ( __stream.rdbuf() )
  152.             delete __stream.ostream_sentry_guard;
  153.           throw;
  154.         }          
  155. #endif // _RWSTD_MULTI_THREAD etc.
  156.  
  157.       }
  158.  
  159.       ~sentry() {
  160.         if( __stream.flags() & ios_base::unitbuf)
  161.         {
  162.           if ( __stream.rdbuf()->pubsync() == -1 )
  163.             __stream.setstate(ios_base::badbit);
  164.         }
  165.  
  166.         if ( __stream.is_synch() )
  167.         {
  168.  
  169.           if ( __rw_is_out(&__stream) ||  __rw_is_err(&__stream) )
  170.           {
  171.             if ( __stream.rdbuf()->pubsync() == -1 )
  172.               __stream.setstate(ios_base::badbit);
  173.           }
  174.         }
  175.  
  176. #ifdef _RWSTD_MULTI_THREAD
  177.         if ( __stream.rdbuf() )
  178.           delete __stream.ostream_sentry_guard;
  179. #endif // _RWSTD_MULTI_THREAD
  180.       }
  181.       operator bool () { return ok_; }
  182.  
  183.     private:
  184.       basic_ostream<charT,traits>& __stream;
  185.       bool ok_;
  186.     };
  187.  
  188.     ostream_type& operator<<(ostream_type& (*pf)(ostream_type&));
  189.     ostream_type& operator<<(ios_base& (*pf)(ios_base&));
  190.     ostream_type& operator<<(ios_type& (*pf)(ios_type&));
  191.  
  192. #ifndef _RWSTD_NO_BOOL
  193.     ostream_type& operator<<(bool n);
  194. #endif
  195.     ostream_type& operator<<(short n);
  196.     ostream_type& operator<<(unsigned short n);
  197.     ostream_type& operator<<(int n);
  198.     ostream_type& operator<<(unsigned int n);
  199.     ostream_type& operator<<(long n);
  200.     ostream_type& operator<<(unsigned long n);
  201.     ostream_type& operator<<(float f);
  202.     ostream_type& operator<<(double f);
  203.     ostream_type& operator<<(long double f); 
  204. #ifdef _RWSTD_LONG_LONG
  205.     ostream_type& operator<<(unsigned _RWSTD_LONG_LONG n); 
  206.     ostream_type& operator<<(_RWSTD_LONG_LONG n); 
  207. #endif
  208.     ostream_type& operator<<(const void *p);
  209.    
  210.     ostream_type& operator<<(basic_streambuf<char_type, traits>& sb)
  211.     {
  212.       ios_base::iostate err = 0;
  213.  
  214. #ifndef _RWSTD_NO_EXCEPTIONS
  215.       try {
  216. #endif
  217.         if ( !(sb.which_open_mode() & ios_base::in) )
  218.           err = ios_base::failbit;
  219.         else
  220.         {
  221.           _TYPENAME basic_ostream<charT, traits>::sentry opfx(*this);
  222.  
  223.           if(opfx)
  224.           {
  225.             int_type    c;
  226.             while( !traits::eq_int_type( (c = sb.sbumpc()),traits::eof()) )
  227.             {
  228.               if( traits::eq_int_type(this->rdbuf()->sputc(c),traits::eof()) )
  229.               {
  230.                 err = ios_base::failbit;
  231.                 break;
  232.               }
  233.             }
  234.           }
  235.         }
  236.  
  237. #ifndef _RWSTD_NO_EXCEPTIONS
  238.       }
  239. #endif
  240.  
  241. #ifndef _RWSTD_NO_EXCEPTIONS
  242.       catch(...)
  243.       {
  244.         bool flag = false;
  245.         try {
  246.           this->setstate(ios_base::badbit);
  247.         }
  248.         catch( ios_base::failure ) { flag= true; }
  249.         if ( flag ) throw;
  250.       }
  251. #endif
  252.       if ( err ) this->setstate(err);
  253.       return *this;
  254.     }
  255.  
  256.     ostream_type& operator<<(basic_streambuf<char_type, traits> *sb)
  257.     {
  258.       ios_base::iostate err = 0; 
  259.  
  260. #ifndef _RWSTD_NO_EXCEPTIONS
  261.       try {
  262. #endif
  263.         if (sb)
  264.         {
  265.           if ( !(sb->which_open_mode() & ios_base::in) )
  266.             err = ios_base::failbit;
  267.           else
  268.           {
  269.             _TYPENAME basic_ostream<charT, traits>::sentry opfx(*this);
  270.  
  271.             if(opfx)
  272.             {
  273.               int_type    c;
  274.               while( !traits::eq_int_type( (c = sb->sbumpc()),traits::eof()))
  275.               {
  276.                 if( traits::eq_int_type(this->rdbuf()->sputc(c),traits::eof()))
  277.                 {
  278.                   err = ios_base::failbit;
  279.                   break;
  280.                 }
  281.               }
  282.             }
  283.           }
  284.         }
  285.         else 
  286.           err = ios_base::badbit;  
  287.  
  288. #ifndef _RWSTD_NO_EXCEPTIONS
  289.       }
  290. #endif
  291.  
  292. #ifndef _RWSTD_NO_EXCEPTIONS
  293.       catch(...)
  294.       {
  295.         bool flag = false;
  296.         try {
  297.           this->setstate(ios_base::badbit);
  298.         }
  299.         catch( ios_base::failure ) { flag= true; }
  300.         if ( flag ) throw;
  301.       }
  302. #endif
  303.       if ( err ) this->setstate(err);
  304.       return *this;
  305.     }
  306.  
  307.     ostream_type& put(char_type c);
  308.     ostream_type& write(const char_type *s, streamsize n);
  309.     ostream_type& flush();
  310.  
  311.     ostream_type& seekp(pos_type pos)
  312.     {
  313. #ifdef _RWSTD_MULTI_THREAD
  314.       if ( this->rdbuf() )
  315. #  ifndef __TURBOC__
  316.         _RWSTDGuard guard(this->rdbuf()->buffer_mutex_);
  317. #  else
  318.       STDGUARD(this->rdbuf()->buffer_mutex_);
  319. #  endif // __TURBOC__
  320. #endif // _RWSTD_MULTI_THREAD
  321.  
  322.       if ( this->bad() ) return *this;
  323.  
  324.       if ( this->rdstate() & ios_base::eofbit )
  325.         clear( this->rdstate() & ~ios_base::eofbit );
  326.    
  327.       if( this->rdbuf()->pubseekpos(pos, ios_base::out) == pos_type(off_type(-1)) )
  328.         this->setstate(ios_base::failbit);
  329.       return *this;
  330.     }
  331.  
  332.     ostream_type& seekp(off_type , ios_base::seekdir );
  333.     pos_type tellp();
  334.  
  335. #ifdef _RWSTD_MULTI_THREAD
  336.     _RWSTDGuard *ostream_sentry_guard;
  337. #endif
  338.   protected:
  339.     basic_ostream();
  340. #ifdef _RWSTD_PROTECTED_OSTREAM_COPY_CONSTRUCTOR
  341.     basic_ostream(const basic_ostream&);
  342. #endif
  343.   };
  344.  
  345. _RWSTD_TEMPLATE
  346.   inline bool __rw_is_out(basic_ostream<char,char_traits<char> >* s)
  347.   { return (void*)s == (void*)&cout; }
  348. #ifndef _RWSTD_NO_WIDE_CHAR
  349. _RWSTD_TEMPLATE
  350.   inline bool __rw_is_out(basic_ostream<wchar_t,char_traits<wchar_t> >* s)
  351.   { return (void*)s == (void*)&wcout; }
  352. #endif
  353.  
  354. _RWSTD_TEMPLATE 
  355.   inline bool __rw_is_err(basic_ostream<char,char_traits<char> >* s)
  356.   { return (void*)s == (void*)&cerr; }
  357. #ifndef _RWSTD_NO_WIDE_CHAR
  358. _RWSTD_TEMPLATE 
  359.   inline bool __rw_is_err(basic_ostream<wchar_t,char_traits<wchar_t> >* s)
  360.   { return (void*)s == (void*)&wcerr; }
  361. #endif
  362.  
  363.   template <class charT, class traits>
  364.   inline bool __rw_is_out(basic_ostream<charT,traits>* s)
  365.   { return false; }
  366.  
  367.   template <class charT, class traits>
  368.   inline bool __rw_is_err(basic_ostream<charT,traits>* s)
  369.   { return false; }
  370.   //
  371.   // Class ostream_iterator
  372.   //
  373.  
  374. #if !defined(_MSC_VER) || defined(__BORLANDC__)
  375.   template <class T, class charT, class traits>
  376. #else
  377.   template <class T, class charT=char, class traits=char_traits<charT> >
  378. #endif
  379.   class _RWSTDExportTemplate ostream_iterator
  380.     : public iterator<output_iterator_tag,T,_TYPENAME traits::off_type,T*,T&>
  381.   {
  382.   protected:
  383.  
  384.     basic_ostream<charT,traits>* __stream;
  385.     const charT*    __str;
  386.  
  387.   public:
  388.     //
  389.     //Types:
  390.     //
  391.     typedef T value_type;
  392.     typedef charT char_type;
  393.     typedef traits traits_type;
  394.     typedef basic_ostream<charT,traits> ostream_type;
  395.  
  396.     ostream_iterator (basic_ostream<charT,traits>& s) 
  397.       : __stream(&s),__str(0) 
  398.     { ; }
  399.     ostream_iterator (basic_ostream<charT,traits>& s,const charT* c) 
  400.       : __stream(&s), __str((charT *)c)  
  401.     { ; }
  402.     ostream_iterator ( const ostream_iterator<T,charT,traits>& x )
  403.       : __stream(x.__stream) , __str(x.__str)
  404.     { ; }
  405.     ostream_iterator<T,charT,traits>& operator= (const T& value)
  406.     { 
  407.       *__stream << value;
  408.       if (__str) *__stream << __str;
  409.       return *this;
  410.     }
  411.     ostream_iterator<T,charT,traits>& operator*  ()    { return *this; }
  412.     ostream_iterator<T,charT,traits>& operator++ ()    { return *this; } 
  413.     ostream_iterator<T,charT,traits>& operator++ (int) { return *this; }
  414.   };
  415. #ifndef _RWSTD_NO_COMPLEX_DEFAULT_TEMPLATES
  416.   typedef basic_ostream<char>                            ostream;
  417. #else
  418.   typedef basic_ostream<char, char_traits<char> >        ostream;
  419. #endif
  420.  
  421. #ifndef _RWSTD_NO_WIDE_CHAR
  422. #ifndef _RWSTD_NO_COMPLEX_DEFAULT_TEMPLATES
  423.   typedef basic_ostream<wchar_t>                         wostream;
  424. #else
  425.   typedef basic_ostream<wchar_t, char_traits<wchar_t> >  wostream;
  426. #endif
  427. #endif
  428.  
  429.   // charT and charT* insertors
  430.  
  431.   template<class charT, class traits>
  432.   basic_ostream<charT, traits>& _RWSTDExportTemplate operator<< ( basic_ostream<charT, traits>&, 
  433.                                                                   charT );
  434.  
  435. #ifndef _RWSTD_NO_OVERLOAD_OF_TEMPLATE_FUNCTION
  436.  
  437.   template<class charT, class traits>
  438.   basic_ostream<charT, traits>& _RWSTDExportTemplate operator<< ( basic_ostream<charT, traits>&, 
  439.                                                                   char );
  440.  
  441. #ifndef _RWSTD_NO_FUNC_PARTIAL_SPEC
  442.   template <class traits>
  443.   basic_ostream<char, traits>& _RWSTDExportTemplate operator<< ( basic_ostream<char, traits>&, 
  444.                                                                  char );
  445. #else
  446.   ostream& _RWSTDExport operator<< ( ostream&, char );
  447. #endif // _RWSTD_NO_FUNC_PARTIAL_SPEC
  448. #endif // _RWSTD_NO_OVERLOAD_OF_TEMPLATE_FUNCTION
  449.   template<class charT, class traits>
  450.   basic_ostream<charT, traits>& _RWSTDExportTemplate operator<< ( basic_ostream<charT, traits>&, 
  451.                                                                   const charT* );
  452.  
  453. #ifndef _RWSTD_NO_OVERLOAD_OF_TEMPLATE_FUNCTION
  454.  
  455.   template<class charT, class traits>
  456.   basic_ostream<charT, traits>& _RWSTDExportTemplate operator<< ( basic_ostream<charT, traits>&, 
  457.                                                                   const char* );
  458.  
  459. #ifndef _RWSTD_NO_FUNC_PARTIAL_SPEC
  460.   template <class traits>
  461.   basic_ostream<char, traits>& _RWSTDExportTemplate operator<< ( basic_ostream<char, traits>&, 
  462.                                                                  const char* );
  463. #else
  464.   ostream& _RWSTDExport operator<< ( ostream&, const char* );
  465. #endif // _RWSTD_NO_FUNC_PARTIAL_SPEC
  466. #endif // _RWSTD_NO_OVERLOAD_OF_TEMPLATE_FUNCTION
  467.  
  468.   /*
  469.    * signed and unsigned insertors
  470.    */
  471.   
  472. #ifndef _RWSTD_NO_SIGNED_CHAR_IN_STREAMS
  473.   template <class traits>
  474.   basic_ostream<char, traits>& _RWSTDExportTemplate operator<< ( basic_ostream<char, traits>&, 
  475.                                                                  unsigned char );
  476.  
  477.   template <class traits>
  478.   basic_ostream<char, traits>& _RWSTDExportTemplate operator<< ( basic_ostream<char, traits>&, 
  479.                                                                  signed char );
  480.  
  481.   template <class traits>
  482.   basic_ostream<char, traits>& _RWSTDExportTemplate operator<< ( basic_ostream<char, traits>&,
  483.                                                                  const unsigned char* );
  484.  
  485.   template <class traits>
  486.   basic_ostream<char, traits>& _RWSTDExportTemplate operator<< ( basic_ostream<char, traits>&,
  487.                                                                  const signed char* );
  488. #endif // _RWSTD_NO_SIGNED_CHAR_IN_STREAMS
  489.  
  490.   /*
  491.    * String insertor
  492.    */
  493.   template<class charT, class traits, class Allocator>
  494.   inline basic_ostream<charT, traits>&
  495.   operator<< (basic_ostream<charT,traits>& os,
  496.           const basic_string<charT,traits,Allocator>& s)
  497.   {
  498.     ios_base::iostate err = 0;
  499.  
  500. #ifndef _RWSTD_NO_EXCEPTIONS
  501.     try {
  502. #endif
  503.   
  504.       _TYPENAME basic_ostream<charT, traits>::sentry opfx(os);
  505.       if (opfx)
  506.       {
  507.     int   dlen =s.length();
  508.     int   pad = os.width() - dlen;
  509.  
  510.     // place right padding
  511.     if( !(os.flags() & ios_base::adjustfield) ||  os.flags() & ios_base::right )
  512.     {
  513.       while(--pad >= 0)
  514.       {
  515.         if( traits::eq_int_type(os.rdbuf()->sputc(os.fill()),traits::eof())) {
  516.           err = ios_base::badbit;
  517.           break;
  518.         }
  519.       }
  520.     }
  521.          
  522.     // output internal padding
  523.     if(os.good() && (os.flags() & ios_base::internal))
  524.     {
  525.       while(--pad >= 0)
  526.       {
  527.         if( traits::eq_int_type(os.rdbuf()->sputc(os.fill()),traits::eof()))
  528.         {
  529.           err = ios_base::badbit;
  530.           break;
  531.         }
  532.       }
  533.     }
  534.  
  535.     if(os.good() && dlen) {
  536.       if(os.rdbuf() && (os.rdbuf()->sputn(s.c_str(), dlen) != dlen))
  537.         err = ios_base::badbit;
  538.     }
  539.  
  540.     // output left padding. 
  541.     if(os.good() && (os.flags() & ios_base::left))
  542.     {
  543.       while(--pad >= 0)
  544.       {
  545.         if( traits::eq_int_type(os.rdbuf()->sputc(os.fill()),traits::eof()))
  546.         {
  547.           err = ios_base::badbit;
  548.           break;
  549.         }
  550.       }
  551.     }
  552.  
  553.     os.width(0);
  554.       }
  555.  
  556. #ifndef _RWSTD_NO_EXCEPTIONS
  557.     }
  558. #endif
  559.  
  560. #ifndef _RWSTD_NO_EXCEPTIONS
  561.     catch(...)
  562.     {
  563.       bool flag = false;
  564.       try {
  565.         os.setstate(ios_base::badbit);
  566.       }
  567.       catch( ios_base::failure ) { flag= true; }
  568.       if ( flag ) throw;
  569.     }
  570. #endif
  571.  
  572.     if ( err ) os.setstate(err);  
  573.  
  574.     return os;
  575.   }
  576.  
  577.   extern ostream _RWSTDExport cout;
  578.   extern ostream _RWSTDExport cerr;
  579.   extern ostream _RWSTDExport clog;
  580.  
  581.   /*
  582.    * declare a couple of standard manipulators
  583.    * global functions
  584.    */
  585.   
  586.   template<class charT, class traits>
  587.   inline basic_ostream<charT, traits>&
  588.   endl(basic_ostream<charT, traits>& os)
  589.   {
  590.     os.put( charT('\n') );
  591.     os.flush(); 
  592.     return os;
  593.   }
  594.  
  595.   template<class charT, class traits>
  596.   inline basic_ostream<charT, traits>&
  597.   ends(basic_ostream<charT, traits>& os)
  598.   {
  599.     os.put( charT(0) );
  600.     return os;
  601.   }
  602.  
  603.   template<class charT, class traits>
  604.   inline basic_ostream<charT, traits>&
  605.   flush(basic_ostream<charT, traits>& os)
  606.   {
  607.     os.flush();
  608.     return os;
  609.   }
  610.  
  611. #ifndef _RWSTD_NO_NAMESPACE
  612. }
  613. #endif
  614.  
  615. #ifdef _RWSTD_COMPILE_INSTANTIATE
  616. #include <ostream.cc>
  617. #endif
  618.  
  619. #endif //__STD_OSTREAM__ 
  620.  
  621. #ifndef __USING_STD_NAMES__
  622.   using namespace std;
  623. #endif
  624. #pragma option pop
  625. #endif /* __OSTREAM_H */
  626.