home *** CD-ROM | disk | FTP | other *** search
/ Magazyn Internet 2000 May / MICD_2000_05.iso / CBuilder5 / INSTALL / DATA1.CAB / Program_Built_Files / Include / ostream.cc < prev    next >
C/C++ Source or Header  |  2000-02-01  |  38KB  |  1,526 lines
  1. #ifndef __OSTREAM_CC
  2. #define __OSTREAM_CC
  3. #pragma option push -b -a8 -pc -Vx- -Ve- -w-inl -w-aus -w-sig
  4. /***************************************************************************
  5.  *
  6.  * ostream.cc - Definitions for the Standard Library ostream classes
  7.  *
  8.  ***************************************************************************
  9.  *
  10.  * Copyright (c) 1994-1999 Rogue Wave Software, Inc.  All Rights Reserved.
  11.  *
  12.  * This computer software is owned by Rogue Wave Software, Inc. and is
  13.  * protected by U.S. copyright laws and other laws and by international
  14.  * treaties.  This computer software is furnished by Rogue Wave Software,
  15.  * Inc. pursuant to a written license agreement and may be used, copied,
  16.  * transmitted, and stored only in accordance with the terms of such
  17.  * license and with the inclusion of the above copyright notice.  This
  18.  * computer software or any other copies thereof may not be provided or
  19.  * otherwise made available to any other person.
  20.  *
  21.  * U.S. Government Restricted Rights.  This computer software is provided
  22.  * with Restricted Rights.  Use, duplication, or disclosure by the
  23.  * Government is subject to restrictions as set forth in subparagraph (c)
  24.  * (1) (ii) of The Rights in Technical Data and Computer Software clause
  25.  * at DFARS 252.227-7013 or subparagraphs (c) (1) and (2) of the
  26.  * Commercial Computer Software û Restricted Rights at 48 CFR 52.227-19,
  27.  * as applicable.  Manufacturer is Rogue Wave Software, Inc., 5500
  28.  * Flatiron Parkway, Boulder, Colorado 80301 USA.
  29.  *
  30.  **************************************************************************/
  31.  
  32. #include <streambuf>
  33.  
  34. #ifndef _RWSTD_NO_NAMESPACE
  35. namespace std {
  36. #endif
  37.  
  38.   /*
  39.    * basic_ostream(basic_streambuf *)
  40.    */
  41.  
  42.   template<class charT, class traits> 
  43.   basic_ostream<charT, traits>::basic_ostream(basic_streambuf<charT, traits> *sb)
  44.   {
  45.     if ( sb )
  46.     {
  47.       if ( sb->which_open_mode() & ios_base::out ) 
  48.         this->init(sb);
  49.       else
  50.         this->init(0);
  51.     } 
  52.     else
  53.       this->init(0);
  54.   }
  55.  
  56.   /*
  57.    * basic_ostream( )
  58.    */
  59.  
  60.   template<class charT, class traits>
  61.   basic_ostream<charT, traits>::basic_ostream( )
  62.   {
  63.   }
  64.  
  65.   /*
  66.    * ~basic_ostream()
  67.    */
  68.  
  69.   template<class charT, class traits>
  70.   basic_ostream<charT, traits>::~basic_ostream()
  71.   {
  72.  
  73.   }
  74.  
  75.   /*
  76.    * basic_ostream& flush()  
  77.    */
  78.  
  79.   template<class charT, class traits>
  80.   basic_ostream<charT, traits>&
  81.   basic_ostream<charT, traits>::flush()
  82.   {
  83.   
  84.     if(this->rdbuf())
  85.     {
  86. #ifdef _RWSTD_MULTI_THREAD
  87.       _RWSTDGuard guard(this->rdbuf()->buffer_mutex_);
  88. #endif
  89.       if(this->rdbuf()->pubsync() == -1)
  90.         this->setstate(ios_base::badbit);
  91.     }
  92.  
  93.     return *this;
  94.   }
  95.   
  96.   /*
  97.    * basic_ostream& operator<<(basic_ostream& (*pf)(basic_ostream&))
  98.    *
  99.    * these are the ostream manipulators (endl, ends, flush)
  100.    */
  101.   template<class charT, class traits>
  102.   basic_ostream<charT, traits>&
  103.   basic_ostream<charT, traits>::
  104.   operator<<(basic_ostream<charT, traits>& (*pf)(basic_ostream<charT, traits>& ))
  105.   {
  106.     return (*pf)(*this);
  107.   }
  108.  
  109.   /*
  110.    * basic_ostream& operator<<(ios_base& (*pf)(ios_base&))
  111.    *
  112.    * outputs the ios_base manipulators
  113.    */
  114.  
  115.   template<class charT, class traits>
  116.   basic_ostream<charT, traits>&
  117.   basic_ostream<charT, traits>::
  118.   operator<<(ios_base& (*pf)(ios_base&))
  119.   {
  120.     (*pf)(*this);
  121.     return *this;
  122.   }
  123.  
  124.   /*
  125.    * basic_ostream& operator<<(basic_ios& (*pf)(basic_ios& ))
  126.    *
  127.    * these are the ios manipulators (dec, hex, ...)
  128.    */
  129.   template<class charT, class traits>
  130.   basic_ostream<charT, traits>&
  131.   basic_ostream<charT, traits>::
  132.   operator<<(basic_ios<charT, traits>& (*pf)(basic_ios<charT, traits>&))
  133.   {
  134.     (*pf)(*this);
  135.     return *this;
  136.   }
  137.  
  138.   /*
  139.    * basic_ostream& operator<< (basic_ostream<charT, traits>& os, const charT *)
  140.    *
  141.    */
  142.  
  143.   template<class charT, class traits>
  144.   basic_ostream<charT, traits>&
  145.   _RWSTDExportTemplate operator<< ( basic_ostream<charT, traits>& os, const charT *s)
  146.   {
  147.     ios_base::iostate err = 0;
  148.  
  149. #ifndef _RWSTD_NO_EXCEPTIONS
  150.     try {
  151. #endif
  152.   
  153.       if ( s )
  154.       {   
  155.         _TYPENAME basic_ostream<charT, traits>::sentry opfx(os);
  156.         if (opfx)
  157.         {
  158.           int   dlen = traits::length(s);
  159.           int   pad = os.width() - dlen;
  160.  
  161.           // place right padding
  162.           if( !(os.flags() & ios_base::adjustfield) ||  (os.flags() & ios_base::right) )
  163.           {
  164.             while(--pad >= 0)
  165.             {
  166.               if( traits::eq_int_type(os.rdbuf()->sputc(os.fill()),traits::eof())) {
  167.                 err = ios_base::badbit;
  168.                 break;
  169.               }
  170.             }
  171.           }
  172.          
  173.           // output internal padding
  174.           if(os.good() && (os.flags() & ios_base::internal))
  175.           {
  176.             while(--pad >= 0)
  177.             {
  178.               if( traits::eq_int_type(os.rdbuf()->sputc(os.fill()),traits::eof()))
  179.               {
  180.                 err = ios_base::badbit;
  181.                 break;
  182.               }
  183.             }
  184.           }
  185.  
  186.           if(os.good() && dlen) {
  187.             if(os.rdbuf() && (os.rdbuf()->sputn(s, dlen) != dlen))
  188.               err = ios_base::badbit;
  189.           }
  190.  
  191.           // output left padding. 
  192.           if(os.good() && (os.flags() & ios_base::left))
  193.           {
  194.             while(--pad >= 0)
  195.             {
  196.               if( traits::eq_int_type(os.rdbuf()->sputc(os.fill()),traits::eof()))
  197.               {
  198.                 err = ios_base::badbit;
  199.                 break;
  200.               }
  201.             }
  202.           }
  203.  
  204.           os.width(0);
  205.         }
  206.       }
  207.       else
  208.         err = ios_base::badbit;
  209.  
  210. #ifndef _RWSTD_NO_EXCEPTIONS
  211.     }
  212. #endif
  213.  
  214. #ifndef _RWSTD_NO_EXCEPTIONS
  215.     catch(...)
  216.     {
  217.       bool flag = false;
  218.       try {
  219.         os.setstate(ios_base::badbit);
  220.       }
  221.       catch( ios_base::failure ) { flag= true; }
  222.       if ( flag ) throw;
  223.     }
  224. #endif
  225.  
  226.     if ( err ) os.setstate(err);  
  227.  
  228.     return os;
  229.   }
  230.  
  231. #ifdef __BORLANDC__
  232. #pragma option -w-aus
  233. #endif
  234.   
  235.   /*
  236.    * basic_ostream& operator<< (basic_ostream<charT, traits>& os, const char *)
  237.    *
  238.    */
  239.  
  240. #ifndef _RWSTD_NO_OVERLOAD_OF_TEMPLATE_FUNCTION
  241.  
  242.   template<class charT, class traits>
  243.   basic_ostream<charT, traits>&
  244.   _RWSTDExportTemplate operator<< ( basic_ostream<charT, traits>& os, const char *s)
  245.   {
  246.     ios_base::iostate err = 0;
  247.  
  248. #ifndef _RWSTD_NO_EXCEPTIONS
  249.     try {
  250. #endif
  251.   
  252.       if ( s ) {   
  253.         _TYPENAME basic_ostream<charT, traits>::sentry opfx(os);
  254.         if (opfx)
  255.         {
  256.           int   dlen = char_traits<char>::length(s);
  257.           int   pad = os.width() - dlen;
  258.  
  259. #ifndef _RWSTD_NO_TEMPLATE_ON_RETURN_TYPE
  260.           const ctype<charT>& ct = use_facet< ctype<charT> >(os.getloc());
  261. #else
  262.           const ctype<charT>& ct = use_facet(os.getloc(),(ctype<charT>*)0);
  263. #endif //  _RWSTD_NO_TEMPLATE_ON_RETURN_TYPE
  264.  
  265.           // place right padding
  266.           if( !(os.flags() & ios_base::adjustfield) ||  (os.flags() & ios_base::right) )
  267.           {
  268.             while(--pad >= 0)
  269.             {
  270.               if( traits::eq_int_type(os.rdbuf()->sputc(os.fill()),traits::eof()))
  271.               {
  272.                 err = ios_base::badbit;
  273.                 break;
  274.               }
  275.             }
  276.           }
  277.          
  278.           // output internal padding
  279.           if(os.good() && (os.flags() & ios_base::internal))
  280.           {
  281.             while(--pad >= 0) {
  282.               if( traits::eq_int_type(os.rdbuf()->sputc(os.fill()),traits::eof()))
  283.               {
  284.                 err = ios_base::badbit;
  285.                 break;
  286.               }
  287.             }
  288.           }
  289.  
  290.           if(os.good() && dlen)
  291.           {
  292.             while ( dlen )
  293.             {
  294.               if( traits::eq_int_type(
  295.                   os.rdbuf()->sputc(ct.widen(*s)),
  296.                   traits::eof())) 
  297.               { 
  298.                 err = ios_base::badbit;    
  299.               }
  300.               s++;
  301.               dlen --;
  302.             }
  303.           }
  304.  
  305.           // output left padding. 
  306.           if(os.good() && (os.flags() & ios_base::left))
  307.           {
  308.             while(--pad >= 0) {
  309.               if( traits::eq_int_type(os.rdbuf()->sputc(os.fill()),traits::eof()))
  310.               {
  311.                 err = ios_base::badbit;
  312.                 break;
  313.               }
  314.             }
  315.           }
  316.  
  317.           os.width(0);
  318.         }
  319.       }
  320.       else
  321.         err = ios_base::badbit;
  322.  
  323. #ifndef _RWSTD_NO_EXCEPTIONS
  324.     }
  325. #endif
  326.  
  327. #ifndef _RWSTD_NO_EXCEPTIONS
  328.     catch(...)
  329.     {
  330.       bool flag = false;
  331.       try {
  332.         os.setstate(ios_base::badbit);
  333.       }
  334.       catch( ios_base::failure ) { flag= true; }
  335.       if ( flag ) throw;
  336.     }
  337. #endif // _RWSTD_NO_EXCEPTIONS
  338.  
  339.     if ( err ) os.setstate(err);  
  340.  
  341.     return os;
  342.   }
  343. #endif // _RWSTD_NO_OVERLOAD_OF_TEMPLATE_FUNCTION
  344.  
  345.   /*
  346.    * basic_ostream& operator<< (basic_ostream<char, traits>& os, const char *)
  347.    *
  348.    */
  349.  
  350. #ifndef _RWSTD_NO_OVERLOAD_OF_TEMPLATE_FUNCTION
  351.  
  352. #ifndef _RWSTD_NO_FUNC_PARTIAL_SPEC
  353.   template<class traits>
  354.   basic_ostream<char, traits>&
  355.   _RWSTDExportTemplate operator<< ( basic_ostream<char, traits>& os, const char *s)
  356.   {
  357.     ios_base::iostate err = 0;
  358.  
  359. #ifndef _RWSTD_NO_EXCEPTIONS
  360.     try {
  361. #endif
  362.       if ( s )
  363.       {   
  364.         _TYPENAME basic_ostream<char, traits>::sentry opfx(os);
  365.         if (opfx)
  366.         {
  367.           int   dlen = traits::length(s);
  368.           int   pad = os.width() - dlen;
  369.  
  370.           // place right padding
  371.           if( !(os.flags() & ios_base::adjustfield) ||  (os.flags() & ios_base::right) )
  372.           {
  373.             while(--pad >= 0)
  374.             {
  375.               if( traits::eq_int_type(os.rdbuf()->sputc(os.fill()),traits::eof()))
  376.               {
  377.                 err = ios_base::badbit;
  378.                 break;
  379.               }
  380.             }
  381.           }
  382.          
  383.           // output internal padding
  384.           if(os.good() && (os.flags() & ios_base::internal))
  385.           {
  386.             while(--pad >= 0) {
  387.               if( traits::eq_int_type(os.rdbuf()->sputc(os.fill()),traits::eof()))
  388.               {
  389.                 err = ios_base::badbit;
  390.                 break;
  391.               }
  392.             }
  393.           }
  394.  
  395.           if(os.good() && dlen) {
  396.             if(os.rdbuf() && (os.rdbuf()->sputn(s, dlen) != dlen))
  397.               err = ios_base::badbit;
  398.           }
  399.  
  400.           // output left padding. 
  401.           if(os.good() && (os.flags() & ios_base::left))
  402.           {
  403.             while(--pad >= 0) {
  404.               if( traits::eq_int_type(os.rdbuf()->sputc(os.fill()),traits::eof()))
  405.               {
  406.                 err = ios_base::badbit;
  407.                 break;
  408.               }
  409.             }
  410.           }
  411.  
  412.           os.width(0);
  413.         }
  414.       }
  415.       else
  416.         err = ios_base::badbit;
  417.  
  418. #ifndef _RWSTD_NO_EXCEPTIONS
  419.     }
  420. #endif
  421.  
  422. #ifndef _RWSTD_NO_EXCEPTIONS
  423.     catch(...)
  424.     {
  425.       bool flag = false;
  426.       try {
  427.         os.setstate(ios_base::badbit);
  428.       }
  429.       catch( ios_base::failure ) { flag= true; }
  430.       if ( flag ) throw;
  431.     }
  432. #endif
  433.  
  434.     if ( err ) os.setstate(err);  
  435.  
  436.     return os;
  437.   }
  438. #endif // _RWSTD_NO_FUNC_PARTIAL_SPEC
  439. #endif // _RWSTD_NO_OVERLOAD_OF_TEMPLATE_FUNCTION
  440.  
  441.   /*
  442.    * basic_ostream& operator<<( basic_ostream<charT, traits>&, charT )
  443.    */
  444.  
  445.   template<class charT, class traits>
  446.   basic_ostream<charT, traits>&
  447.   _RWSTDExportTemplate operator<< (basic_ostream<charT, traits>& os, charT c)
  448.   {
  449.     ios_base::iostate err = 0;
  450.  
  451. #ifndef _RWSTD_NO_EXCEPTIONS
  452.     try {
  453. #endif
  454.  
  455.       _TYPENAME basic_ostream<charT, traits>::sentry opfx(os); 
  456.  
  457.       if(opfx) 
  458.       {
  459.         int   pad = os.width() - 1;
  460.  
  461.         // place right padding
  462.         if( !(os.flags() & ios_base::adjustfield) ||  (os.flags() & ios_base::right) )
  463.         {
  464.           while(--pad >= 0)
  465.           {
  466.             if( traits::eq_int_type(os.rdbuf()->sputc(os.fill()),traits::eof()))
  467.             {
  468.               err = ios_base::badbit;
  469.               break;
  470.             }
  471.           }
  472.         }
  473.          
  474.         // output internal padding
  475.         if(os.good() && (os.flags() & ios_base::internal))
  476.         {
  477.           while(--pad >= 0)
  478.           {
  479.             if( traits::eq_int_type(os.rdbuf()->sputc(os.fill()),traits::eof()))
  480.             {
  481.               err = ios_base::badbit;
  482.               break;
  483.             }
  484.           }
  485.         }
  486.  
  487.         if(os.good())
  488.         {
  489.           if( traits::eq_int_type(os.rdbuf()->sputc(c),traits::eof())) 
  490.             err = ios_base::badbit;    
  491.         }
  492.  
  493.         // output left padding. 
  494.         if(os.good() && (os.flags() & ios_base::left))
  495.         {
  496.           while(--pad >= 0)
  497.           {
  498.             if( traits::eq_int_type(os.rdbuf()->sputc(os.fill()),traits::eof()))
  499.             {
  500.               err = ios_base::badbit;
  501.               break;
  502.             }
  503.           }
  504.         }
  505.  
  506.         os.width(0);
  507.      
  508.       }
  509.  
  510. #ifndef _RWSTD_NO_EXCEPTIONS
  511.     }
  512. #endif
  513.  
  514. #ifndef _RWSTD_NO_EXCEPTIONS
  515.     catch(...)
  516.     {
  517.       bool flag = false;
  518.       try {
  519.         os.setstate(ios_base::failbit);
  520.       }
  521.       catch( ios_base::failure ) { flag= true; }
  522.       if ( flag ) throw;
  523.     }
  524. #endif
  525.     if ( err ) os.setstate(err); 
  526.     return os;
  527.   }
  528.  
  529.   /*
  530.    * basic_ostream& operator<<( basic_ostream<charT, traits>&, char )
  531.    */
  532.  
  533. #ifndef _RWSTD_NO_OVERLOAD_OF_TEMPLATE_FUNCTION
  534.  
  535.   template<class charT, class traits>
  536.   basic_ostream<charT, traits>&
  537.   _RWSTDExportTemplate operator<< (basic_ostream<charT, traits>& os, char c)
  538.   {
  539.     ios_base::iostate err = 0;
  540.  
  541. #ifndef _RWSTD_NO_EXCEPTIONS
  542.     try {
  543. #endif
  544.       _TYPENAME basic_ostream<charT, traits>::sentry opfx(os); 
  545.  
  546.       if(opfx) 
  547.       {
  548. #ifndef _RWSTD_NO_TEMPLATE_ON_RETURN_TYPE
  549.         const ctype<charT>& ct = use_facet< ctype<charT> >(os.getloc());
  550. #else
  551.         const ctype<charT>& ct = use_facet(os.getloc(),(ctype<charT>*)0);
  552. #endif // _RWSTD_NO_TEMPLATE_ON_RETURN_TYPE
  553.  
  554.         int   pad = os.width() - 1;
  555.  
  556.         // place right padding
  557.         if( !(os.flags() & ios_base::adjustfield) ||  (os.flags() & ios_base::right) )
  558.         {
  559.           while(--pad >= 0)
  560.           {
  561.             if( traits::eq_int_type(os.rdbuf()->sputc(os.fill()),traits::eof()))
  562.             {
  563.               err = ios_base::badbit;
  564.               break;
  565.             }
  566.           }
  567.         }
  568.          
  569.         // output internal padding
  570.         if(os.good() && (os.flags() & ios_base::internal))
  571.         {
  572.           while(--pad >= 0)
  573.           {
  574.             if( traits::eq_int_type(os.rdbuf()->sputc(os.fill()),traits::eof()))
  575.             {
  576.               err = ios_base::badbit;
  577.               break;
  578.             }
  579.           }
  580.         }
  581.  
  582.         if(os.good())
  583.         {
  584.           if( traits::eq_int_type(os.rdbuf()->sputc(ct.widen(c)),traits::eof())) 
  585.             err = ios_base::badbit;      
  586.         }
  587.  
  588.         // output left padding. 
  589.         if(os.good() && (os.flags() & ios_base::left))
  590.         {
  591.           while(--pad >= 0)
  592.           {
  593.             if( traits::eq_int_type(os.rdbuf()->sputc(os.fill()),traits::eof()))
  594.             {
  595.               err = ios_base::badbit;
  596.               break;
  597.             }
  598.           }
  599.         }
  600.         os.width(0);    
  601.       }
  602.  
  603. #ifndef _RWSTD_NO_EXCEPTIONS
  604.     }
  605. #endif
  606.  
  607. #ifndef _RWSTD_NO_EXCEPTIONS
  608.     catch(...)
  609.     {
  610.       bool flag = false;
  611.       try {
  612.         os.setstate(ios_base::failbit);
  613.       }
  614.       catch( ios_base::failure ) { flag= true; }
  615.       if ( flag ) throw;
  616.     }
  617. #endif
  618.  
  619.     if ( err ) os.setstate(err); 
  620.  
  621.     return os;
  622.   }
  623. #endif // _RWSTD_NO_OVERLOAD_OF_TEMPLATE_FUNCTION 
  624.  
  625.   /*
  626.    * basic_ostream& operator<<( basic_ostream<char, traits>&, char )
  627.    *
  628.    */
  629.  
  630. #ifndef _RWSTD_NO_OVERLOAD_OF_TEMPLATE_FUNCTION
  631. #ifndef _RWSTD_NO_FUNC_PARTIAL_SPEC
  632.  
  633.   template<class traits>
  634.   basic_ostream<char, traits>&
  635.   _RWSTDExportTemplate operator<< (basic_ostream<char, traits>& os, char c)
  636.   {
  637.     ios_base::iostate err = 0;
  638.  
  639. #ifndef _RWSTD_NO_EXCEPTIONS
  640.     try {
  641. #endif
  642.  
  643.       _TYPENAME basic_ostream<char, traits>::sentry opfx(os); 
  644.  
  645.       if(opfx) 
  646.       {
  647.         int   pad = os.width() - 1;
  648.  
  649.         // place right padding
  650.         if( !(os.flags() & ios_base::adjustfield) ||  (os.flags() & ios_base::right) )
  651.         {
  652.           while(--pad >= 0)
  653.           {
  654.             if( traits::eq_int_type(os.rdbuf()->sputc(os.fill()),traits::eof()))
  655.             {
  656.               err = ios_base::badbit;
  657.               break;
  658.             }
  659.           }
  660.         }
  661.          
  662.         // output internal padding
  663.         if(os.good() && (os.flags() & ios_base::internal))
  664.         {
  665.           while(--pad >= 0)
  666.           {
  667.             if( traits::eq_int_type(os.rdbuf()->sputc(os.fill()),traits::eof()))
  668.             {
  669.               err = ios_base::badbit;
  670.               break;
  671.             }
  672.           }
  673.         }
  674.  
  675.         if(os.good()) {
  676.           if( traits::eq_int_type(os.rdbuf()->sputc(c),traits::eof())) 
  677.             err = ios_base::badbit;       
  678.         }
  679.  
  680.         // output left padding. 
  681.         if(os.good() && (os.flags() & ios_base::left))
  682.         {
  683.           while(--pad >= 0)
  684.           {
  685.             if( traits::eq_int_type(os.rdbuf()->sputc(os.fill()),traits::eof()))
  686.             {
  687.               err = ios_base::badbit;
  688.               break;
  689.             }
  690.           }
  691.         }
  692.         os.width(0);    
  693.       }
  694.  
  695. #ifndef _RWSTD_NO_EXCEPTIONS
  696.     }
  697. #endif
  698.  
  699. #ifndef _RWSTD_NO_EXCEPTIONS
  700.     catch(...)
  701.     {
  702.       bool flag = false;
  703.       try {
  704.         os.setstate(ios_base::failbit);
  705.       }
  706.       catch( ios_base::failure ) { flag= true; }
  707.       if ( flag ) throw;
  708.     }
  709. #endif
  710.  
  711.     if ( err ) os.setstate(err); 
  712.  
  713.     return os;
  714.   }
  715. #endif // _RWSTD_NO_FUNC_PARTIAL_SPEC 
  716. #endif // _RWSTD_NO_OVERLOAD_OF_TEMPLATE_FUNCTION 
  717.  
  718. #ifndef _RWSTD_NO_SIGNED_CHAR_IN_STREAMS
  719.  
  720.   /*
  721.    * ostream& operator<<(basic_ostream<char,traits>&,unsigned char )
  722.    */
  723.  
  724.   template <class traits>
  725.   basic_ostream<char, traits>&
  726.   _RWSTDExportTemplate operator<<(basic_ostream<char, traits>& os,unsigned char uc)
  727.   {
  728.     return (os << (char)uc);
  729.   }
  730.  
  731.   /*
  732.    * ostream& operator<<(basic_ostream<char, traits>&,signed char )
  733.    */
  734.  
  735.   template <class traits>
  736.   basic_ostream<char, traits>&
  737.   _RWSTDExportTemplate operator<<(basic_ostream<char, traits>& os,signed char sc)
  738.   {
  739.     return (os << (char)sc);
  740.   }
  741.  
  742.   /*
  743.    * ostream& operator<<(basic_ostream<char, traits>&,const unsigned char* )
  744.    */
  745.  
  746.   template <class traits>
  747.   basic_ostream<char, traits>&
  748.   _RWSTDExportTemplate operator<<(basic_ostream<char, traits>& os,const unsigned char* uc)
  749.   {
  750.     return (os << (char *)uc);
  751.   }
  752.  
  753.   /*
  754.    * ostream& operator<<(basic_ostream<char, traits>&,const signed char* )
  755.    */
  756.  
  757.   template <class traits>
  758.   basic_ostream<char, traits>&
  759.   _RWSTDExportTemplate operator<<(basic_ostream<char, traits>& os,const signed char* sc)
  760.   {
  761.     return (os << (char *)sc);
  762.   }
  763. #endif // _RWSTD_NO_SIGNED_CHAR_IN_STREAMS
  764.   /*
  765.    * basic_ostream& operator<<(bool n)
  766.    */
  767.  
  768. #ifndef _RWSTD_NO_BOOL
  769.  
  770.   template<class charT, class traits>
  771.   basic_ostream<charT, traits>& 
  772.   basic_ostream<charT, traits>::operator<<(bool n)
  773.   {
  774.     ios_base::iostate err = 0;
  775.  
  776. #ifndef _RWSTD_NO_EXCEPTIONS
  777.     try {
  778. #endif
  779.  
  780.       _TYPENAME basic_ostream<charT, traits>::sentry opfx(*this);
  781.       if (opfx)
  782.       {
  783.         if (
  784. #ifndef _RWSTD_NO_TEMPLATE_ON_RETURN_TYPE
  785.             use_facet<num_put<charT,ostreambuf_iterator<charT,traits> > >(this->getloc())
  786. #else
  787.             use_facet(this->getloc(),(num_put<charT,ostreambuf_iterator<charT,traits> >*)0)
  788. #endif // _RWSTD_NO_TEMPLATE_ON_RETURN_TYPE
  789.             .put(ostreambuf_iterator<charT,traits>(*this),*this,this->fill(),n).failed() )
  790.           err = ios_base::badbit;
  791.         this->width(0);
  792.       }
  793.  
  794. #ifndef _RWSTD_NO_EXCEPTIONS
  795.     }
  796. #endif
  797.  
  798. #ifndef _RWSTD_NO_EXCEPTIONS
  799.     catch(...)
  800.     {
  801.       bool flag = false;
  802.       try {
  803.         this->setstate(ios_base::badbit);
  804.       }
  805.       catch( ios_base::failure ) { flag= true; }
  806.       if ( flag ) throw;
  807.     }
  808. #endif // _RWSTD_NO_EXCEPTIONS 
  809.     if ( err ) this->setstate(err);
  810.     return *this;
  811.   }
  812.  
  813. #endif // _RWSTD_NO_BOOL
  814.  
  815.   /*
  816.    * basic_ostream& operator<<(short)
  817.    */
  818.  
  819.   template<class charT, class traits>
  820.   basic_ostream<charT, traits>&
  821.   basic_ostream<charT, traits>::operator<<(short n)
  822.   {
  823.     ios_base::iostate err = 0;
  824.  
  825. #ifndef _RWSTD_NO_EXCEPTIONS
  826.     try {
  827. #endif  
  828.       _TYPENAME basic_ostream<charT, traits>::sentry opfx(*this);
  829.       if (opfx)
  830.       {
  831.         if (
  832. #ifndef _RWSTD_NO_TEMPLATE_ON_RETURN_TYPE
  833.             use_facet<num_put<charT,ostreambuf_iterator<charT,traits> > >(this->getloc())
  834. #else
  835.             use_facet(this->getloc(),(num_put<charT,ostreambuf_iterator<charT,traits> >*)0)
  836. #endif
  837. #ifndef _RWSTD_STRICT_ANSI
  838.             .put(ostreambuf_iterator<charT,traits>(*this),*this,basic_ios<charT,traits>::fill(),n).failed() )
  839. #else
  840.             .put(ostreambuf_iterator<charT,traits>(*this),*this,basic_ios<charT,traits>::fill(),(long)n).failed() )
  841. #endif
  842.           err = ios_base::badbit;
  843.         this->width(0);
  844.       }
  845.  
  846. #ifndef _RWSTD_NO_EXCEPTIONS
  847.     }
  848. #endif
  849.  
  850. #ifndef _RWSTD_NO_EXCEPTIONS
  851.     catch(...)
  852.     {
  853.       bool flag = false;
  854.       try {
  855.         this->setstate(ios_base::badbit);
  856.       }
  857.       catch( ios_base::failure ) { flag= true; }
  858.       if ( flag ) throw;
  859.     }
  860. #endif
  861.     if ( err ) this->setstate(err);
  862.     return *this;
  863.   }
  864.  
  865.   /*
  866.    * basic_ostream& operator<<(unsigned short)
  867.    */
  868.  
  869.   template<class charT, class traits>
  870.   basic_ostream<charT, traits>&
  871.   basic_ostream<charT, traits>::operator<<(unsigned short n)
  872.   {
  873.     ios_base::iostate err = 0;
  874.  
  875. #ifndef _RWSTD_NO_EXCEPTIONS
  876.     try {
  877. #endif  
  878.       _TYPENAME basic_ostream<charT, traits>::sentry opfx(*this);
  879.       if (opfx)
  880.       {
  881.         if (
  882. #ifndef _RWSTD_NO_TEMPLATE_ON_RETURN_TYPE
  883.             use_facet<num_put<charT,ostreambuf_iterator<charT,traits> > >(this->getloc())
  884. #else
  885.             use_facet(this->getloc(),(num_put<charT,ostreambuf_iterator<charT,traits> >*)0)
  886. #endif // _RWSTD_NO_TEMPLATE_ON_RETURN_TYPE
  887. #ifndef _RWSTD_STRICT_ANSI
  888.             .put(ostreambuf_iterator<charT,traits>(*this),*this,basic_ios<charT,traits>::fill(),n).failed() )
  889. #else
  890.             .put(ostreambuf_iterator<charT,traits>(*this),*this,basic_ios<charT,traits>::fill(),(unsigned long)n).failed() )
  891. #endif
  892.           err = ios_base::badbit;
  893.         this->width(0);
  894.       }
  895.  
  896. #ifndef _RWSTD_NO_EXCEPTIONS
  897.     }
  898. #endif
  899.  
  900. #ifndef _RWSTD_NO_EXCEPTIONS
  901.     catch(...)
  902.     {
  903.       bool flag = false;
  904.       try {
  905.         this->setstate(ios_base::badbit);
  906.       }
  907.       catch( ios_base::failure ) { flag= true; }
  908.       if ( flag ) throw;
  909.     }
  910. #endif // _RWSTD_NO_EXCEPTIONS 
  911.     if ( err ) this->setstate(err);
  912.     return *this; 
  913.   }
  914.   /*
  915.    * basic_ostream& operator<<(int)
  916.    */
  917.  
  918.   template<class charT, class traits>
  919.   basic_ostream<charT, traits>&
  920.   basic_ostream<charT, traits>::operator<<(int n)
  921.   {
  922.     ios_base::iostate err = 0;
  923.  
  924. #ifndef _RWSTD_NO_EXCEPTIONS
  925.     try {
  926. #endif  
  927.  
  928.       _TYPENAME basic_ostream<charT, traits>::sentry opfx(*this);
  929.       if (opfx)
  930.       {
  931.         if ( 
  932. #ifndef _RWSTD_NO_TEMPLATE_ON_RETURN_TYPE
  933.             use_facet<num_put<charT,ostreambuf_iterator<charT,traits> > >(this->getloc())
  934. #else
  935.             use_facet(this->getloc(),(num_put<charT,ostreambuf_iterator<charT,traits> >*)0)
  936. #endif // _RWSTD_NO_TEMPLATE_ON_RETURN_TYPE
  937. #ifndef _RWSTD_STRICT_ANSI
  938.             .put(ostreambuf_iterator<charT,traits>(*this),*this,basic_ios<charT,traits>::fill(),n).failed() )
  939. #else
  940.             .put(ostreambuf_iterator<charT,traits>(*this),*this,basic_ios<charT,traits>::fill(),(long)n).failed() )
  941. #endif
  942.           err = ios_base::badbit;
  943.         this->width(0);
  944.       }
  945.  
  946. #ifndef _RWSTD_NO_EXCEPTIONS
  947.     }
  948. #endif
  949.  
  950. #ifndef _RWSTD_NO_EXCEPTIONS
  951.     catch(...)
  952.     {
  953.       bool flag = false;
  954.       try {
  955.         this->setstate(ios_base::badbit);
  956.       }
  957.       catch( ios_base::failure ) { flag= true; }
  958.       if ( flag ) throw;
  959.     }
  960. #endif
  961.     if ( err ) this->setstate(err);  
  962.     return *this; 
  963.   }
  964.   /*
  965.    * basic_ostream& operator<<(unsigned int)
  966.    */
  967.  
  968.   template<class charT, class traits>
  969.   basic_ostream<charT, traits>&
  970.   basic_ostream<charT, traits>::operator<<(unsigned int n)
  971.   {
  972.     ios_base::iostate err = 0;
  973.  
  974. #ifndef _RWSTD_NO_EXCEPTIONS
  975.     try {
  976. #endif 
  977.  
  978.       _TYPENAME basic_ostream<charT, traits>::sentry opfx(*this);
  979.       if (opfx)
  980.       {
  981.         if (
  982. #ifndef _RWSTD_NO_TEMPLATE_ON_RETURN_TYPE
  983.             use_facet<num_put<charT,ostreambuf_iterator<charT,traits> > >(this->getloc())
  984. #else
  985.             use_facet(this->getloc(),(num_put<charT,ostreambuf_iterator<charT,traits> >*)0)
  986. #endif // _RWSTD_NO_TEMPLATE_ON_RETURN_TYPE
  987. #ifndef _RWSTD_STRICT_ANSI
  988.             .put(ostreambuf_iterator<charT,traits>(*this),*this,basic_ios<charT,traits>::fill(),n).failed() )
  989. #else
  990.             .put(ostreambuf_iterator<charT,traits>(*this),*this,basic_ios<charT,traits>::fill(),(unsigned long)n).failed() )
  991. #endif
  992.           err = ios_base::badbit;
  993.         this->width(0);
  994.       }
  995.  
  996. #ifndef _RWSTD_NO_EXCEPTIONS
  997.     }
  998. #endif
  999.  
  1000. #ifndef _RWSTD_NO_EXCEPTIONS
  1001.     catch(...)
  1002.     {
  1003.       bool flag = false;
  1004.       try {
  1005.         this->setstate(ios_base::badbit);
  1006.       }
  1007.       catch( ios_base::failure ) { flag= true; }
  1008.       if ( flag ) throw;
  1009.     }
  1010. #endif
  1011.     if ( err ) this->setstate(err);
  1012.     return *this; 
  1013.   }
  1014.  
  1015.   /*
  1016.    * basic_ostream& operator<<(long)
  1017.    */
  1018.  
  1019.   template<class charT, class traits>
  1020.   basic_ostream<charT, traits>&
  1021.   basic_ostream<charT, traits>::operator<<(long n)
  1022.   {
  1023.     ios_base::iostate err = 0;
  1024.  
  1025. #ifndef _RWSTD_NO_EXCEPTIONS
  1026.     try {
  1027. #endif
  1028.  
  1029.       _TYPENAME basic_ostream<charT, traits>::sentry opfx(*this);
  1030.       if (opfx)
  1031.       {
  1032.         if (
  1033. #ifndef _RWSTD_NO_TEMPLATE_ON_RETURN_TYPE
  1034.             use_facet<num_put<charT,ostreambuf_iterator<charT,traits> > >(this->getloc())
  1035. #else
  1036.             use_facet(this->getloc(),(num_put<charT,ostreambuf_iterator<charT,traits> >*)0)
  1037. #endif
  1038.             .put(ostreambuf_iterator<charT,traits>(*this),*this,basic_ios<charT,traits>::fill(),n).failed() )
  1039.           err = ios_base::badbit;
  1040.         this->width(0);
  1041.       } 
  1042.  
  1043. #ifndef _RWSTD_NO_EXCEPTIONS
  1044.     }
  1045. #endif
  1046.  
  1047. #ifndef _RWSTD_NO_EXCEPTIONS
  1048.     catch(...)
  1049.     {
  1050.       bool flag = false;
  1051.       try {
  1052.         this->setstate(ios_base::badbit);
  1053.       }
  1054.       catch( ios_base::failure ) { flag= true; }
  1055.       if ( flag ) throw;
  1056.     }
  1057. #endif // _RWSTD_NO_EXCEPTIONS 
  1058.     if ( err ) this->setstate(err);
  1059.     return *this; 
  1060.   }
  1061.  
  1062.   /*
  1063.    * basic_ostream& operator<<(unsigned long)
  1064.    */
  1065.  
  1066.   template<class charT, class traits>
  1067.   basic_ostream<charT, traits>&
  1068.   basic_ostream<charT, traits>::operator<<(unsigned long n)
  1069.   {
  1070.     ios_base::iostate err = 0;
  1071.  
  1072. #ifndef _RWSTD_NO_EXCEPTIONS
  1073.     try {
  1074. #endif
  1075.       _TYPENAME basic_ostream<charT, traits>::sentry opfx(*this);
  1076.       if (opfx)
  1077.       {
  1078.         if (
  1079. #ifndef _RWSTD_NO_TEMPLATE_ON_RETURN_TYPE
  1080.             use_facet<num_put<charT,ostreambuf_iterator<charT,traits> > >(this->getloc())
  1081. #else
  1082.             use_facet(this->getloc(),(num_put<charT,ostreambuf_iterator<charT,traits> >*)0)
  1083. #endif
  1084.             .put(ostreambuf_iterator<charT,traits>(*this),*this,basic_ios<charT,traits>::fill(),n).failed() )
  1085.           err = ios_base::badbit;
  1086.         this->width(0);
  1087.       }
  1088.  
  1089. #ifndef _RWSTD_NO_EXCEPTIONS
  1090.     }
  1091. #endif
  1092.  
  1093. #ifndef _RWSTD_NO_EXCEPTIONS
  1094.     catch(...)
  1095.     {
  1096.       bool flag = false;
  1097.       try {
  1098.         this->setstate(ios_base::badbit);
  1099.       }
  1100.       catch( ios_base::failure ) { flag= true; }
  1101.       if ( flag ) throw;
  1102.     }
  1103. #endif
  1104.     if ( err ) this->setstate(err);
  1105.     return *this; 
  1106.   }
  1107.  
  1108.   /*
  1109.    * basic_ostream& operator<<(float)
  1110.    */
  1111.  
  1112.   template<class charT, class traits>
  1113.   basic_ostream<charT, traits>&
  1114.   basic_ostream<charT, traits>::operator<<(float n)
  1115.   {
  1116.     ios_base::iostate err = 0;
  1117.  
  1118. #ifndef _RWSTD_NO_EXCEPTIONS
  1119.     try {
  1120. #endif
  1121.  
  1122.       _TYPENAME basic_ostream<charT, traits>::sentry opfx(*this);
  1123.       if (opfx)
  1124.       {
  1125.         if (
  1126. #ifndef _RWSTD_NO_TEMPLATE_ON_RETURN_TYPE
  1127.             use_facet<num_put<charT,ostreambuf_iterator<charT,traits> > >(this->getloc())
  1128. #else
  1129.             use_facet(this->getloc(),(num_put<charT,ostreambuf_iterator<charT,traits> >*)0)
  1130. #endif // _RWSTD_NO_TEMPLATE_ON_RETURN_TYPE
  1131.             .put(ostreambuf_iterator<charT,traits>(*this),*this,basic_ios<charT,traits>::fill(),(double)n).failed() )
  1132.           err = ios_base::badbit;
  1133.         this->width(0);
  1134.       }
  1135.  
  1136. #ifndef _RWSTD_NO_EXCEPTIONS
  1137.     }
  1138. #endif
  1139.  
  1140. #ifndef _RWSTD_NO_EXCEPTIONS
  1141.     catch(...)
  1142.     {
  1143.       bool flag = false;
  1144.       try {
  1145.         this->setstate(ios_base::badbit);
  1146.       }
  1147.       catch( ios_base::failure ) { flag= true; }
  1148.       if ( flag ) throw;
  1149.     }
  1150. #endif
  1151.     if ( err ) this->setstate(err);
  1152.     return *this;
  1153.   }
  1154.  
  1155.   /*
  1156.    * basic_ostream& operator<<(double)
  1157.    */
  1158.  
  1159.   template<class charT, class traits>
  1160.   basic_ostream<charT, traits>&
  1161.   basic_ostream<charT, traits>::operator<<(double n)
  1162.   {
  1163.     ios_base::iostate err = 0;
  1164.  
  1165. #ifndef _RWSTD_NO_EXCEPTIONS
  1166.     try {
  1167. #endif
  1168.  
  1169.       _TYPENAME basic_ostream<charT, traits>::sentry opfx(*this);
  1170.       if (opfx)
  1171.       {
  1172.         if (
  1173. #ifndef _RWSTD_NO_TEMPLATE_ON_RETURN_TYPE
  1174.             use_facet<num_put<charT,ostreambuf_iterator<charT,traits> > >(this->getloc())
  1175. #else
  1176.             use_facet(this->getloc(),(num_put<charT,ostreambuf_iterator<charT,traits> >*)0)
  1177. #endif // _RWSTD_NO_TEMPLATE_ON_RETURN_TYPE
  1178.             .put(ostreambuf_iterator<charT,traits>(*this),*this,basic_ios<charT,traits>::fill(),n).failed() )
  1179.           err = ios_base::badbit;
  1180.         this->width(0);
  1181.       }
  1182.  
  1183. #ifndef _RWSTD_NO_EXCEPTIONS
  1184.     }
  1185. #endif
  1186.  
  1187. #ifndef _RWSTD_NO_EXCEPTIONS
  1188.     catch(...)
  1189.     {
  1190.       bool flag = false;
  1191.       try {
  1192.         this->setstate(ios_base::badbit);
  1193.       }
  1194.       catch( ios_base::failure ) { flag= true; }
  1195.       if ( flag ) throw;
  1196.     }
  1197. #endif
  1198.     if ( err ) this->setstate(err);
  1199.     return *this;
  1200.   }
  1201.  
  1202.   /*
  1203.    * basic_ostream& operator<<(long double)
  1204.    */
  1205.  
  1206.   template<class charT, class traits>
  1207.   basic_ostream<charT, traits>&
  1208.   basic_ostream<charT, traits>::operator<<(long double n)
  1209.   {
  1210.     ios_base::iostate err = 0;
  1211.  
  1212. #ifndef _RWSTD_NO_EXCEPTIONS
  1213.     try {
  1214. #endif
  1215.       _TYPENAME basic_ostream<charT, traits>::sentry opfx(*this);
  1216.       if (opfx)
  1217.       {
  1218.         if (
  1219. #ifndef _RWSTD_NO_TEMPLATE_ON_RETURN_TYPE
  1220.             use_facet<num_put<charT,ostreambuf_iterator<charT,traits> > >(this->getloc())
  1221. #else
  1222.             use_facet(this->getloc(),(num_put<charT,ostreambuf_iterator<charT,traits> >*)0)
  1223. #endif // _RWSTD_NO_TEMPLATE_ON_RETURN_TYPE
  1224.             .put(ostreambuf_iterator<charT,traits>(*this),*this,basic_ios<charT,traits>::fill(),n).failed() )
  1225.           err = ios_base::badbit;
  1226.         this->width(0);
  1227.       }
  1228.  
  1229. #ifndef _RWSTD_NO_EXCEPTIONS
  1230.     }
  1231. #endif
  1232.  
  1233. #ifndef _RWSTD_NO_EXCEPTIONS
  1234.     catch(...)
  1235.     {
  1236.       bool flag = false;
  1237.       try {
  1238.         this->setstate(ios_base::badbit);
  1239.       }
  1240.       catch( ios_base::failure ) { flag= true; }
  1241.       if ( flag ) throw;
  1242.     }
  1243. #endif
  1244.     if ( err ) this->setstate(err);
  1245.     return *this;
  1246.   }
  1247.  
  1248. /*
  1249.  * basic_ostream& operator<<(_RWSTD_LONG_LONG)
  1250.  */
  1251.  
  1252. #ifdef _RWSTD_LONG_LONG
  1253.  
  1254.   template<class charT, class traits>
  1255.   basic_ostream<charT, traits>&
  1256.   basic_ostream<charT, traits>::operator<<(_RWSTD_LONG_LONG n)
  1257.   {
  1258.     ios_base::iostate err = 0;
  1259.  
  1260. #ifndef _RWSTD_NO_EXCEPTIONS
  1261.     try {
  1262. #endif
  1263.  
  1264.       _TYPENAME basic_ostream<charT, traits>::sentry opfx(*this);
  1265.       if (opfx)
  1266.       {
  1267.     if (
  1268. #ifndef _RWSTD_NO_TEMPLATE_ON_RETURN_TYPE
  1269.         use_facet<num_put<charT,ostreambuf_iterator<charT,traits> > >(this->getloc())
  1270. #else
  1271.         use_facet(this->getloc(),(num_put<charT,ostreambuf_iterator<charT,traits> >*)0)
  1272. #endif
  1273.         .put(ostreambuf_iterator<charT,traits>(*this),*this,basic_ios<charT,traits>::fill(),n).failed() )
  1274.       err = ios_base::badbit;
  1275.    
  1276.     this->width(0);
  1277.  
  1278.       }
  1279.  
  1280. #ifndef _RWSTD_NO_EXCEPTIONS
  1281.     }
  1282. #endif
  1283.  
  1284. #ifndef _RWSTD_NO_EXCEPTIONS
  1285.     catch(...)
  1286.     {
  1287.       bool flag = false;
  1288.       try {
  1289.     this->setstate(ios_base::badbit);
  1290.       }
  1291.       catch( ios_base::failure ) { flag= true; }
  1292.       if ( flag ) throw;
  1293.     }
  1294. #endif
  1295.  
  1296.     if ( err ) this->setstate(err);
  1297.  
  1298.     return *this;
  1299.   }
  1300.  
  1301. /*
  1302.  * basic_ostream& operator<<(unsigned _RWSTD_LONG_LONG)
  1303.  */
  1304.  
  1305.   template<class charT, class traits>
  1306.   basic_ostream<charT, traits>&
  1307.   basic_ostream<charT, traits>::operator<<(unsigned _RWSTD_LONG_LONG n)
  1308.   {
  1309.     ios_base::iostate err = 0;
  1310.  
  1311. #ifndef _RWSTD_NO_EXCEPTIONS
  1312.     try {
  1313. #endif
  1314.  
  1315.       _TYPENAME basic_ostream<charT, traits>::sentry opfx(*this);
  1316.       if (opfx)
  1317.       {
  1318.     if (
  1319. #ifndef _RWSTD_NO_TEMPLATE_ON_RETURN_TYPE
  1320.         use_facet<num_put<charT,ostreambuf_iterator<charT,traits> > >(this->getloc())
  1321. #else
  1322.         use_facet(this->getloc(),(num_put<charT,ostreambuf_iterator<charT,traits> >*)0)
  1323. #endif
  1324.         .put(ostreambuf_iterator<charT,traits>(*this),*this,basic_ios<charT,traits>::fill(),n).failed() )
  1325.       err = ios_base::badbit;
  1326.    
  1327.     this->width(0);
  1328.  
  1329.       }
  1330.  
  1331. #ifndef _RWSTD_NO_EXCEPTIONS
  1332.     }
  1333. #endif
  1334.  
  1335. #ifndef _RWSTD_NO_EXCEPTIONS
  1336.     catch(...)
  1337.     {
  1338.       bool flag = false;
  1339.       try {
  1340.     this->setstate(ios_base::badbit);
  1341.       }
  1342.       catch( ios_base::failure ) { flag= true; }
  1343.       if ( flag ) throw;
  1344.     }
  1345. #endif
  1346.  
  1347.     if ( err ) this->setstate(err);
  1348.  
  1349.     return *this;
  1350.   }
  1351. #endif //_RWSTD_LONG_LONG
  1352.  
  1353.   /*
  1354.    * basic_ostream& operator<<(const void *)
  1355.    */
  1356.  
  1357.   template<class charT, class traits>
  1358.   basic_ostream<charT, traits>&
  1359.   basic_ostream<charT, traits>::operator<<(const void *p)
  1360.   {
  1361.     ios_base::iostate err = 0;
  1362.  
  1363. #ifndef _RWSTD_NO_EXCEPTIONS
  1364.     try {
  1365. #endif
  1366.  
  1367.       _TYPENAME basic_ostream<charT, traits>::sentry opfx(*this);
  1368.       if (opfx)
  1369.       {
  1370.         if (
  1371. #ifndef _RWSTD_NO_TEMPLATE_ON_RETURN_TYPE
  1372.             use_facet<num_put<charT,ostreambuf_iterator<charT,traits> > >(this->getloc())
  1373. #else
  1374.             use_facet(this->getloc(),(num_put<charT,ostreambuf_iterator<charT,traits> >*)0)
  1375. #endif // _RWSTD_NO_TEMPLATE_ON_RETURN_TYPE
  1376.             .put(ostreambuf_iterator<charT,traits>(*this),*this,this->fill(),p).failed() )
  1377.           err = ios_base::badbit;
  1378.         this->width(0);
  1379.       }
  1380.  
  1381. #ifndef _RWSTD_NO_EXCEPTIONS
  1382.     }
  1383. #endif
  1384.  
  1385. #ifndef _RWSTD_NO_EXCEPTIONS
  1386.     catch(...)
  1387.     {
  1388.       bool flag = false;
  1389.       try {
  1390.         this->setstate(ios_base::badbit);
  1391.       }
  1392.       catch( ios_base::failure ) { flag= true; }
  1393.       if ( flag ) throw;
  1394.     }
  1395. #endif
  1396.     if ( err ) this->setstate(err);
  1397.     return *this;
  1398.   }
  1399.  
  1400.   /*
  1401.    * basic_ostream& put(char_type)
  1402.    */
  1403.  
  1404.   template<class charT, class traits>
  1405.   basic_ostream<charT, traits>&
  1406.   basic_ostream<charT, traits>::put(char_type c)
  1407.   {
  1408.     ios_base::iostate err = 0; 
  1409.  
  1410. #ifndef _RWSTD_NO_EXCEPTIONS
  1411.     try {
  1412. #endif
  1413.       _TYPENAME basic_ostream<charT, traits>::sentry opfx(*this);
  1414.       if(opfx)
  1415.       {
  1416.         if( traits::eq_int_type(this->rdbuf()->sputc(c),traits::eof()) )  
  1417.           err = ios_base::badbit;    
  1418.       }
  1419.  
  1420. #ifndef _RWSTD_NO_EXCEPTIONS
  1421.     }
  1422. #endif
  1423.  
  1424. #ifndef _RWSTD_NO_EXCEPTIONS
  1425.     catch(...)
  1426.     {
  1427.       bool flag = false;
  1428.       try {
  1429.         this->setstate(ios_base::badbit);
  1430.       }
  1431.       catch( ios_base::failure ) { flag= true; }
  1432.       if ( flag ) throw;
  1433.     }
  1434. #endif
  1435.     if ( err ) this->setstate(err);
  1436.     return *this;
  1437.   }
  1438.  
  1439.   /*
  1440.    * basic_ostream& write(const char_type *, streamsize)
  1441.    */
  1442.  
  1443.   template<class charT, class traits>
  1444.   basic_ostream<charT, traits>&
  1445.   basic_ostream<charT, traits>::write(const char_type *s, streamsize n)
  1446.   {
  1447.     ios_base::iostate err = 0; 
  1448.  
  1449. #ifndef _RWSTD_NO_EXCEPTIONS
  1450.     try {
  1451. #endif 
  1452.  
  1453.       if(s)
  1454.       {
  1455.         _TYPENAME basic_ostream<charT, traits>::sentry opfx(*this);
  1456.         if(opfx)
  1457.         {
  1458.           if(this->rdbuf()->sputn(s, n)!=n) 
  1459.             err = ios_base::badbit;
  1460.         }
  1461.       }
  1462.       else
  1463.         err = ios_base::badbit;
  1464.  
  1465. #ifndef _RWSTD_NO_EXCEPTIONS
  1466.     }
  1467. #endif
  1468.  
  1469. #ifndef _RWSTD_NO_EXCEPTIONS
  1470.     catch(...)
  1471.     {
  1472.       bool flag = false;
  1473.       try {
  1474.         this->setstate(ios_base::badbit);
  1475.       }
  1476.       catch( ios_base::failure ) { flag= true; }
  1477.       if ( flag ) throw;
  1478.     }
  1479. #endif
  1480.     if ( err ) this->setstate(err);
  1481.     return *this;
  1482.   }
  1483.   template<class charT, class traits>
  1484.   basic_ostream<charT, traits>&
  1485.   basic_ostream<charT, traits>::seekp(off_type off, ios_base::seekdir dir)
  1486.   {
  1487. #ifdef _RWSTD_MULTI_THREAD
  1488.     if ( this->rdbuf() ) {
  1489.       _RWSTDGuard guard(this->rdbuf()->buffer_mutex_);
  1490. #endif
  1491.     if ( this->fail() ) return *this;
  1492.     this->rdbuf()->pubseekoff(off, dir, ios_base::out) == pos_type(off_type(-1));
  1493.  
  1494.     return *this;
  1495. #ifdef _RWSTD_MULTI_THREAD
  1496.     }
  1497. #endif
  1498.   }
  1499.  
  1500.   template<class charT, class traits>
  1501.   _TYPENAME basic_ostream<charT,traits>::pos_type
  1502.   basic_ostream<charT, traits>::tellp()
  1503.   {
  1504.     pos_type    p;
  1505.  
  1506. #ifdef _RWSTD_MULTI_THREAD
  1507.     if ( this->rdbuf() ) {
  1508.       _RWSTDGuard guard(this->rdbuf()->buffer_mutex_);
  1509. #endif // _RWSTD_MULTI_THREAD 
  1510.  
  1511.     if ( this->fail() ) return pos_type(-1);
  1512.  
  1513.     p = this->rdbuf()->pubseekoff(0, ios_base::cur,ios_base::out);
  1514.  
  1515.     return p;
  1516. #ifdef _RWSTD_MULTI_THREAD
  1517.     }
  1518. #endif // _RWSTD_MULTI_THREAD 
  1519.   }
  1520. #ifndef _RWSTD_NO_NAMESPACE
  1521. }
  1522. #endif
  1523.  
  1524. #pragma option pop
  1525. #endif /* __OSTREAM_CC */
  1526.