home *** CD-ROM | disk | FTP | other *** search
/ Tricks of the Windows Gam…ming Gurus (2nd Edition) / Disc2.iso / vc98 / include / istream < prev    next >
Encoding:
Text File  |  1998-06-16  |  17.5 KB  |  618 lines
  1. // istream standard header
  2.  
  3. #if     _MSC_VER > 1000
  4. #pragma once
  5. #endif
  6.  
  7. #ifndef _ISTREAM_
  8. #define _ISTREAM_
  9. #include <ostream>
  10.  
  11. #ifdef  _MSC_VER
  12. #pragma pack(push,8)
  13. #endif  /* _MSC_VER */
  14. _STD_BEGIN
  15.         // TEMPLATE CLASS basic_istream
  16. template<class _E, class _Tr = char_traits<_E> >
  17.     class basic_istream : virtual public basic_ios<_E, _Tr> {
  18. public:
  19.     typedef basic_istream<_E, _Tr> _Myt;
  20.     typedef basic_ios<_E, _Tr> _Myios;
  21.     typedef basic_streambuf<_E, _Tr> _Mysb;
  22.     typedef istreambuf_iterator<_E, _Tr> _Iter;
  23.     typedef ctype<_E> _Ctype;
  24.     typedef num_get<_E, _Iter> _Nget;
  25.     explicit basic_istream(_Mysb *_S, bool _Isstd = false)
  26.         : _Chcount(0) {init(_S, _Isstd); }
  27.     basic_istream(_Uninitialized)
  28.         {_Addstd(); }
  29.     virtual ~basic_istream()
  30.         {}
  31.     class sentry {
  32.     public:
  33.         explicit sentry(_Myt& _Is, bool _Noskip = false)
  34.             : _Ok(_Is.ipfx(_Noskip)) {}
  35.         operator bool() const
  36.             {return (_Ok); }
  37.     private:
  38.         bool _Ok;
  39.         };
  40.     bool ipfx(bool _Noskip = false)
  41.         {if (good())
  42.             {if (tie() != 0)
  43.                 tie()->flush();
  44.             if (!_Noskip && flags() & skipws)
  45.                 {const _Ctype& _Fac = _USE(getloc(), _Ctype);
  46.                 _TRY_IO_BEGIN
  47.                 int_type _C = rdbuf()->sgetc();
  48.                 while (!_Tr::eq_int_type(_Tr::eof(), _C)
  49.                     && _Fac.is(_Ctype::space,
  50.                         _Tr::to_char_type(_C)))
  51.                     _C = rdbuf()->snextc();
  52.                 _CATCH_IO_END }
  53.             if (good())
  54.                 return (true); }
  55.         setstate(failbit);
  56.         return (false); }
  57.     void isfx()
  58.         {}
  59.     _Myt& operator>>(_Myt& (__cdecl *_F)(_Myt&))
  60.         {return ((*_F)(*this)); }
  61.     _Myt& operator>>(_Myios& (__cdecl *_F)(_Myios&))
  62.         {(*_F)(*(_Myios *)this);
  63.         return (*this); }
  64.     _Myt& operator>>(ios_base& (__cdecl *_F)(ios_base&))
  65.         {(*_F)(*(ios_base *)this);
  66.         return (*this); }
  67.     _Myt& operator>>(_Bool& _X)
  68.         {iostate _St = goodbit;
  69.         const sentry _Ok(*this);
  70.         if (_Ok)
  71.             {const _Nget& _Fac = _USE(getloc(), _Nget);
  72.             _TRY_IO_BEGIN
  73.             _Fac.get(_Iter(rdbuf()), _Iter(0), *this, _St, _X);
  74.             _CATCH_IO_END }
  75.         setstate(_St);
  76.         return (*this); }
  77.     _Myt& operator>>(short& _X)
  78.         {iostate _St = goodbit;
  79.         const sentry _Ok(*this);
  80.         if (_Ok)
  81.             {long _Y;
  82.             const _Nget& _Fac = _USE(getloc(), _Nget);
  83.             _TRY_IO_BEGIN
  84.             _Fac.get(_Iter(rdbuf()), _Iter(0), *this, _St, _Y);
  85.             _CATCH_IO_END
  86.             if (_St & failbit || _Y < SHRT_MIN || SHRT_MAX < _Y)
  87.                 _St |= failbit;
  88.             else
  89.                 _X = (short)_Y; }
  90.         setstate(_St);
  91.         return (*this); }
  92.     _Myt& operator>>(unsigned short& _X)
  93.         {iostate _St = goodbit;
  94.         const sentry _Ok(*this);
  95.         if (_Ok)
  96.             {const _Nget& _Fac = _USE(getloc(), _Nget);
  97.             _TRY_IO_BEGIN
  98.             _Fac.get(_Iter(rdbuf()), _Iter(0), *this, _St, _X);
  99.             _CATCH_IO_END }
  100.         setstate(_St);
  101.         return (*this); }
  102.     _Myt& operator>>(int& _X)
  103.         {iostate _St = goodbit;
  104.         const sentry _Ok(*this);
  105.         if (_Ok)
  106.             {long _Y;
  107.             const _Nget& _Fac = _USE(getloc(), _Nget);
  108.             _TRY_IO_BEGIN
  109.             _Fac.get(_Iter(rdbuf()), _Iter(0), *this, _St, _Y);
  110.             _CATCH_IO_END
  111.             if (_St & failbit || _Y < INT_MIN || INT_MAX < _Y)
  112.                 _St |= failbit;
  113.             else
  114.                 _X = _Y; }
  115.         setstate(_St);
  116.         return (*this); }
  117.     _Myt& operator>>(unsigned int& _X)
  118.         {iostate _St = goodbit;
  119.         const sentry _Ok(*this);
  120.         if (_Ok)
  121.             {const _Nget& _Fac = _USE(getloc(), _Nget);
  122.             _TRY_IO_BEGIN
  123.             _Fac.get(_Iter(rdbuf()), _Iter(0), *this, _St, _X);
  124.             _CATCH_IO_END }
  125.         setstate(_St);
  126.         return (*this); }
  127.     _Myt& operator>>(long& _X)
  128.         {iostate _St = goodbit;
  129.         const sentry _Ok(*this);
  130.         if (_Ok)
  131.             {const _Nget& _Fac = _USE(getloc(), _Nget);
  132.             _TRY_IO_BEGIN
  133.             _Fac.get(_Iter(rdbuf()), _Iter(0), *this, _St, _X);
  134.             _CATCH_IO_END }
  135.         setstate(_St);
  136.         return (*this); }
  137.     _Myt& operator>>(unsigned long& _X)
  138.         {iostate _St = goodbit;
  139.         const sentry _Ok(*this);
  140.         if (_Ok)
  141.             {const _Nget& _Fac = _USE(getloc(), _Nget);
  142.             _TRY_IO_BEGIN
  143.             _Fac.get(_Iter(rdbuf()), _Iter(0), *this, _St, _X);
  144.             _CATCH_IO_END }
  145.         setstate(_St);
  146.         return (*this); }
  147.     _Myt& operator>>(float& _X)
  148.         {iostate _St = goodbit;
  149.         const sentry _Ok(*this);
  150.         if (_Ok)
  151.             {const _Nget& _Fac = _USE(getloc(), _Nget);
  152.             _TRY_IO_BEGIN
  153.             _Fac.get(_Iter(rdbuf()), _Iter(0), *this, _St, _X);
  154.             _CATCH_IO_END }
  155.         setstate(_St);
  156.         return (*this); }
  157.     _Myt& operator>>(double& _X)
  158.         {iostate _St = goodbit;
  159.         const sentry _Ok(*this);
  160.         if (_Ok)
  161.             {const _Nget& _Fac = _USE(getloc(), _Nget);
  162.             _TRY_IO_BEGIN
  163.             _Fac.get(_Iter(rdbuf()), _Iter(0), *this, _St, _X);
  164.             _CATCH_IO_END }
  165.         setstate(_St);
  166.         return (*this); }
  167.     _Myt& operator>>(long double& _X)
  168.         {iostate _St = goodbit;
  169.         const sentry _Ok(*this);
  170.         if (_Ok)
  171.             {const _Nget& _Fac = _USE(getloc(), _Nget);
  172.             _TRY_IO_BEGIN
  173.             _Fac.get(_Iter(rdbuf()), _Iter(0), *this, _St, _X);
  174.             _CATCH_IO_END }
  175.         setstate(_St);
  176.         return (*this); }
  177.     _Myt& operator>>(void *& _X)
  178.         {iostate _St = goodbit;
  179.         const sentry _Ok(*this);
  180.         if (_Ok)
  181.             {const _Nget& _Fac = _USE(getloc(), _Nget);
  182.             _TRY_IO_BEGIN
  183.             _Fac.get(_Iter(rdbuf()), _Iter(0), *this, _St, _X);
  184.             _CATCH_IO_END }
  185.         setstate(_St);
  186.         return (*this); }
  187.     _Myt& operator>>(_Mysb *_Pb)
  188.         {iostate _St = goodbit;
  189.         bool _Copied = false;
  190.         const sentry _Ok(*this);
  191.         if (_Ok && _Pb != 0)
  192.             {_TRY_IO_BEGIN
  193.             int_type _C = rdbuf()->sgetc();
  194.             for (; ; _C = rdbuf()->snextc())
  195.                 if (_Tr::eq_int_type(_Tr::eof(), _C))
  196.                     {_St |= eofbit;
  197.                     break; }
  198.                 else
  199.                     {_TRY_BEGIN
  200.                         if (_Tr::eq_int_type(_Tr::eof(),
  201.                             _Pb->sputc(_Tr::to_char_type(_C))))
  202.                             break;
  203.                     _CATCH_ALL
  204.                         break;
  205.                     _CATCH_END
  206.                     _Copied = true; }
  207.             _CATCH_IO_END }
  208.         setstate(!_Copied ? _St | failbit : _St);
  209.         return (*this); }
  210.     int_type get()
  211.         {int_type _C;
  212.         iostate _St = goodbit;
  213.         _Chcount = 0;
  214.         const sentry _Ok(*this, true);
  215.         if (!_Ok)
  216.             _C = _Tr::eof();
  217.         else
  218.             {_TRY_IO_BEGIN
  219.             _C = rdbuf()->sbumpc();
  220.             if (_Tr::eq_int_type(_Tr::eof(), _C))
  221.                 _St |= eofbit | failbit;
  222.             else
  223.                 ++_Chcount;
  224.             _CATCH_IO_END }
  225.         setstate(_St);
  226.         return (_C); }
  227.     _Myt& get(_E *_S, streamsize _N)
  228.         {return (get(_S, _N, widen('\n'))); }
  229.     _Myt& get(_E *_S, streamsize _N, _E _D)
  230.         {iostate _St = goodbit;
  231.         _Chcount = 0;
  232.         const sentry _Ok(*this, true);
  233.         if (_Ok && 0 < _N)
  234.             {_TRY_IO_BEGIN
  235.             int_type _C = rdbuf()->sgetc();
  236.             for (; 0 < --_N; _C = rdbuf()->snextc())
  237.                 if (_Tr::eq_int_type(_Tr::eof(), _C))
  238.                     {_St |= eofbit;
  239.                     break; }
  240.                 else if (_Tr::to_char_type(_C) == _D)
  241.                     break;
  242.                 else
  243.                     *_S++ = _Tr::to_char_type(_C), ++_Chcount;
  244.             _CATCH_IO_END }
  245.         setstate(_Chcount == 0 ? _St | failbit : _St);
  246.         *_S = _E(0);
  247.         return (*this); }
  248.     _Myt& get(_E& _X)
  249.         {int_type _C = get();
  250.         if (!_Tr::eq_int_type(_Tr::eof(), _C))
  251.             _X = _Tr::to_char_type(_C);
  252.         return (*this); }
  253.     _Myt& get(_Mysb& _Sb)
  254.         {return (get(_Sb, widen('\n'))); }
  255.     _Myt& get(_Mysb& _Sb, _E _D)
  256.         {iostate _St = goodbit;
  257.         _Chcount = 0;
  258.         const sentry _Ok(*this, true);
  259.         if (_Ok)
  260.             {_TRY_IO_BEGIN
  261.             int_type _C = rdbuf()->sgetc();
  262.             for (; ; _C = rdbuf()->snextc())
  263.                 if (_Tr::eq_int_type(_Tr::eof(), _C))
  264.                     {_St |= eofbit;
  265.                     break; }
  266.                 else
  267.                     {_TRY_BEGIN
  268.                         _E _Ch = _Tr::to_char_type(_C);
  269.                         if (_Ch == _D
  270.                             || _Tr::eq_int_type(_Tr::eof(),
  271.                                 _Sb.sputc(_Ch)))
  272.                             break;
  273.                     _CATCH_ALL
  274.                         break;
  275.                     _CATCH_END
  276.                     ++_Chcount; }
  277.             _CATCH_IO_END }
  278.         if (_Chcount == 0)
  279.             _St |= failbit;
  280.         setstate(_St);
  281.         return (*this); }
  282.     _Myt& getline(_E *_S, streamsize _N)
  283.         {return (getline(_S, _N, widen('\n'))); }
  284.     _Myt& getline(_E *_S, streamsize _N, _E _D)
  285.         {iostate _St = goodbit;
  286.         _Chcount = 0;
  287.         const sentry _Ok(*this, true);
  288.         if (_Ok && 0 < _N)
  289.             {int_type _Di = _Tr::to_int_type(_D);
  290.             _TRY_IO_BEGIN
  291.             int_type _C = rdbuf()->sgetc();
  292.             for (; ; _C = rdbuf()->snextc())
  293.                 if (_Tr::eq_int_type(_Tr::eof(), _C))
  294.                     {_St |= eofbit;
  295.                     break; }
  296.                 else if (_C == _Di)
  297.                     {++_Chcount;
  298.                     rdbuf()->stossc();
  299.                     break; }
  300.                 else if (--_N <= 0)
  301.                     {_St |= failbit;
  302.                     break; }
  303.                 else
  304.                     {++_Chcount;
  305.                     *_S++ = _Tr::to_char_type(_C); }
  306.             _CATCH_IO_END }
  307.         *_S = _E(0);
  308.         setstate(_Chcount == 0 ? _St | failbit : _St);
  309.         return (*this); }
  310.     _Myt& ignore(streamsize _N = 1, int_type _Di = _Tr::eof())
  311.         {iostate _St = goodbit;
  312.         _Chcount = 0;
  313.         const sentry _Ok(*this, true);
  314.         if (_Ok && 0 < _N)
  315.             {_TRY_IO_BEGIN
  316.             for (; ; )
  317.                 {int_type _C;
  318.                 if (_N != INT_MAX && --_N < 0)
  319.                     break;
  320.                 else if (_Tr::eq_int_type(_Tr::eof(),
  321.                     _C = rdbuf()->sbumpc()))
  322.                     {_St |= eofbit;
  323.                     break; }
  324.                 else
  325.                     {++_Chcount;
  326.                     if (_C == _Di)
  327.                         break; }}
  328.             _CATCH_IO_END }
  329.         setstate(_St);
  330.         return (*this); }
  331.     _Myt& read(_E *_S, streamsize _N)
  332.         {iostate _St = goodbit;
  333.         _Chcount = 0;
  334.         const sentry _Ok(*this, true);
  335.         if (_Ok)
  336.             {_TRY_IO_BEGIN
  337.             const streamsize _M = rdbuf()->sgetn(_S, _N);
  338.             _Chcount += _M;
  339.             if (_M != _N)
  340.                 _St |= eofbit | failbit;
  341.             _CATCH_IO_END }
  342.         setstate(_St);
  343.         return (*this); }
  344.     streamsize readsome(_E *_S, streamsize _N)
  345.         {iostate _St = goodbit;
  346.         _Chcount = 0;
  347.         int _M;
  348.         if (rdbuf() == 0)
  349.             _St |= failbit;
  350.         else if ((_M = rdbuf()->in_avail()) < 0)
  351.             _St |= eofbit;
  352.         else if (0 < _M)
  353.             read(_S, _M < _N ? _M : _N);
  354.         setstate(_St);
  355.         return (gcount()); }
  356.     int_type peek()
  357.         {iostate _St = goodbit;
  358.         _Chcount = 0;
  359.         int_type _C;
  360.         const sentry _Ok(*this, true);
  361.         if (!_Ok)
  362.             _C = _Tr::eof();
  363.         else
  364.             {_TRY_IO_BEGIN
  365.             if (_Tr::eq_int_type(_Tr::eof(),
  366.                 _C = rdbuf()->sgetc()))
  367.                 _St |= eofbit;
  368.             _CATCH_IO_END }
  369.         setstate(_St);
  370.         return (_C); }
  371.     _Myt& putback(_E _X)
  372.         {iostate _St = goodbit;
  373.         _Chcount = 0;
  374.         const sentry _Ok(*this, true);
  375.         if (_Ok)
  376.             {_TRY_IO_BEGIN
  377.             if (_Tr::eq_int_type(_Tr::eof(),
  378.                 rdbuf()->sputbackc(_X)))
  379.                 _St |= badbit;
  380.             _CATCH_IO_END }
  381.         setstate(_St);
  382.         return (*this); }
  383.     _Myt& unget()
  384.         {iostate _St = goodbit;
  385.         _Chcount = 0;
  386.         const sentry _Ok(*this, true);
  387.         if (_Ok)
  388.             {_TRY_IO_BEGIN
  389.             if (_Tr::eq_int_type(_Tr::eof(),
  390.                 rdbuf()->sungetc()))
  391.                 _St |= badbit;
  392.             _CATCH_IO_END }
  393.         setstate(_St);
  394.         return (*this); }
  395.     streamsize gcount() const
  396.         {return (_Chcount); }
  397.     int sync()
  398.         {iostate _St = goodbit;
  399.         int _Ans;
  400.         if (rdbuf() == 0)
  401.             _Ans = -1;
  402.         else if (rdbuf()->pubsync() == -1)
  403.             _St |= badbit, _Ans = -1;
  404.         else
  405.             _Ans = 0;
  406.         setstate(_St);
  407.         return (_Ans); }
  408.     _Myt& seekg(pos_type _P)
  409.         {if (!fail())
  410.             rdbuf()->pubseekpos(_P, in);
  411.         return (*this); }
  412.     _Myt& seekg(off_type _O, ios_base::seekdir _W)
  413.         {if (!fail())
  414.             rdbuf()->pubseekoff(_O, _W, in);
  415.         return (*this); }
  416.     pos_type tellg()
  417.         {if (!fail())
  418.             return (rdbuf()->pubseekoff(0, cur, in));
  419.         else
  420.             return (streampos(_BADOFF)); }
  421. private:
  422.     streamsize _Chcount;
  423.     };
  424.  
  425. #ifdef _DLL
  426. #pragma warning(disable:4231) /* the extern before template is a non-standard extension */
  427. extern template class _CRTIMP basic_istream<char, char_traits<char> >;
  428. extern template class _CRTIMP basic_istream<wchar_t, char_traits<wchar_t> >;
  429. #pragma warning(default:4231) /* restore previous warning */
  430. #endif        // _DLL
  431.  
  432.         // TEMPLATE CLASS basic_iostream
  433. template<class _E, class _Tr = char_traits<_E> >
  434.     class basic_iostream : public basic_istream<_E, _Tr>,
  435.         public basic_ostream<_E, _Tr> {
  436. public:
  437.     explicit basic_iostream(basic_streambuf<_E, _Tr> *_S)
  438.         : basic_istream<_E, _Tr>(_S), basic_ostream<_E, _Tr>(_S, false, false)
  439.         {}
  440.     virtual ~basic_iostream()
  441.         {}
  442.     };
  443.  
  444. #ifdef _DLL
  445. #pragma warning(disable:4231) /* the extern before template is a non-standard extension */
  446. extern template class _CRTIMP basic_iostream<char, char_traits<char> >;
  447. extern template class _CRTIMP basic_iostream<wchar_t, char_traits<wchar_t> >;
  448. #pragma warning(default:4231) /* restore previous warning */
  449. #endif        // _DLL
  450.  
  451.  
  452.  
  453.         // EXTRACTORS
  454. template<class _E, class _Tr> inline
  455.     basic_istream<_E, _Tr>& __cdecl operator>>(
  456.         basic_istream<_E, _Tr>& _I, _E *_X)
  457.     {typedef basic_istream<_E, _Tr> _Myis;
  458.     typedef ctype<_E> _Ctype;
  459.     ios_base::iostate _St = ios_base::goodbit;
  460.     _E *_S = _X;
  461.     const _Myis::sentry _Ok(_I);
  462.     if (_Ok)
  463.         {const _Ctype& _Fac = _USE(_I.getloc(), _Ctype);
  464.         _TRY_IO_BEGIN
  465.         int _N = 0 < _I.width() ? _I.width() : INT_MAX;
  466.         _Myis::int_type _C = _I.rdbuf()->sgetc();
  467.         for (; 0 < --_N; _C = _I.rdbuf()->snextc())
  468.             if (_Tr::eq_int_type(_Tr::eof(), _C))
  469.                 {_St |= ios_base::eofbit;
  470.                 break; }
  471.             else if (_Fac.is(_Ctype::space,
  472.                 _Tr::to_char_type(_C)))
  473.                 break;
  474.             else
  475.                 *_S++ = _Tr::to_char_type(_C);
  476.         _CATCH_IO_(_I) }
  477.     *_S = _E(0);
  478.     _I.width(0);
  479.     _I.setstate(_S == _X ? _St | ios_base::failbit : _St);
  480.     return (_I); }
  481. template<class _E, class _Tr> inline
  482.     basic_istream<_E, _Tr>& __cdecl operator>>(
  483.         basic_istream<_E, _Tr>& _I, _E& _X)
  484.     {typedef basic_istream<_E, _Tr> _Myis;
  485.     _Myis::int_type _C;
  486.     ios_base::iostate _St = ios_base::goodbit;
  487.     const _Myis::sentry _Ok(_I);
  488.     if (_Ok)
  489.         {_TRY_IO_BEGIN
  490.         _C = _I.rdbuf()->sbumpc();
  491.         if (_Tr::eq_int_type(_Tr::eof(), _C))
  492.             _St |= ios_base::eofbit | ios_base::failbit;
  493.         else
  494.             _X = _Tr::to_char_type(_C);
  495.         _CATCH_IO_(_I) }
  496.     _I.setstate(_St);
  497.     return (_I); }
  498. template<class _E, class _Tr> inline
  499.     basic_istream<_E, _Tr>& __cdecl operator>>(
  500.         basic_istream<_E, _Tr>& _I, signed char *_X)
  501.     {return (_I >> (char *)_X); }
  502. template<class _E, class _Tr> inline
  503.     basic_istream<_E, _Tr>& __cdecl operator>>(
  504.         basic_istream<_E, _Tr>& _I, signed char& _C)
  505.     {return (_I >> (char&)_C); }
  506. template<class _E, class _Tr> inline
  507.     basic_istream<_E, _Tr>& __cdecl operator>>(
  508.         basic_istream<_E, _Tr>& _I, unsigned char *_X)
  509.     {return (_I >> (char *)_X); }
  510. template<class _E, class _Tr> inline
  511.     basic_istream<_E, _Tr>& __cdecl operator>>(
  512.         basic_istream<_E, _Tr>& _I, unsigned char& _C)
  513.     {return (_I >> (char&)_C); }
  514. template<class _E, class _Tr> inline
  515.     basic_istream<_E, _Tr>& __cdecl operator>>(
  516.         basic_istream<_E, _Tr>& _I, signed short * _X)
  517.     {return (_I >> (wchar_t *)_X); }
  518.         // MANIPULATORS
  519. template<class _E, class _Tr> inline
  520.     basic_istream<_E, _Tr>& __cdecl ws(basic_istream<_E, _Tr>& _I)
  521.     {typedef basic_istream<_E, _Tr> _Myis;
  522.     typedef ctype<_E> _Ctype;
  523.     ios_base::iostate _St = ios_base::goodbit;
  524.     const _Myis::sentry _Ok(_I, true);
  525.     if (_Ok)
  526.         {const _Ctype& _Fac = _USE(_I.getloc(), _Ctype);
  527.         _TRY_IO_BEGIN
  528.         for (_Tr::int_type _C = _I.rdbuf()->sgetc(); ;
  529.             _C = _I.rdbuf()->snextc())
  530.             if (_Tr::eq_int_type(_Tr::eof(), _C))
  531.                 {_St |= ios_base::eofbit;
  532.                 break; }
  533.             else if (!_Fac.is(_Ctype::space,
  534.                 _Tr::to_char_type(_C)))
  535.                 break;
  536.         _CATCH_IO_(_I) }
  537.     _I.setstate(_St);
  538.     return (_I); }
  539. _CRTIMP inline basic_istream<char, char_traits<char> >&
  540.     __cdecl ws(basic_istream<char, char_traits<char> >& _I)
  541.     {typedef char _E;
  542.     typedef char_traits<_E> _Tr;
  543.     ios_base::iostate _St = ios_base::goodbit;
  544.     const basic_istream<_E, _Tr>::sentry _Ok(_I, true);
  545.     if (_Ok)
  546.         {const ctype<_E>& _Fac = _USE(_I.getloc(), ctype<_E>);
  547.         _TRY_IO_BEGIN
  548.         for (_Tr::int_type _C = _I.rdbuf()->sgetc(); ;
  549.             _C = _I.rdbuf()->snextc())
  550.             if (_Tr::eq_int_type(_Tr::eof(), _C))
  551.                 {_St |= ios_base::eofbit;
  552.                 break; }
  553.             else if (!_Fac.is(ctype<_E>::space,
  554.                 _Tr::to_char_type(_C)))
  555.                 break;
  556.         _CATCH_IO_(_I) }
  557.     _I.setstate(_St);
  558.     return (_I); }
  559. _CRTIMP inline basic_istream<wchar_t, char_traits<wchar_t> >&
  560.     __cdecl ws(basic_istream<wchar_t, char_traits<wchar_t> >& _I)
  561.     {typedef wchar_t _E;
  562.     typedef char_traits<_E> _Tr;
  563.     ios_base::iostate _St = ios_base::goodbit;
  564.     const basic_istream<_E, _Tr>::sentry _Ok(_I, true);
  565.     if (_Ok)
  566.         {const ctype<_E>& _Fac = _USE(_I.getloc(), ctype<_E>);
  567.         _TRY_IO_BEGIN
  568.         for (_Tr::int_type _C = _I.rdbuf()->sgetc(); ;
  569.             _C = _I.rdbuf()->snextc())
  570.             if (_Tr::eq_int_type(_Tr::eof(), _C))
  571.                 {_St |= ios_base::eofbit;
  572.                 break; }
  573.             else if (_Fac.is(ctype<_E>::space,
  574.                 _Tr::to_char_type(_C)))
  575.                 break;
  576.         _CATCH_IO_(_I) }
  577.     _I.setstate(_St);
  578.     return (_I); }
  579.  
  580.  
  581. #ifdef _DLL
  582. #pragma warning(disable:4231) /* the extern before template is a non-standard extension */
  583.  
  584. extern template _CRTIMP basic_istream<char, char_traits<char> >& __cdecl operator>>(
  585.        basic_istream<char, char_traits<char> >&, char *);
  586. extern template _CRTIMP basic_istream<char, char_traits<char> >& __cdecl operator>>(
  587.        basic_istream<char, char_traits<char> >&, char&);
  588. extern template _CRTIMP basic_istream<char, char_traits<char> >& __cdecl operator>>(
  589.        basic_istream<char, char_traits<char> >&, signed char *);
  590. extern template _CRTIMP basic_istream<char, char_traits<char> >& __cdecl operator>>(
  591.        basic_istream<char, char_traits<char> >&, signed char&);
  592. extern template _CRTIMP basic_istream<char, char_traits<char> >& __cdecl operator>>(
  593.        basic_istream<char, char_traits<char> >&, unsigned char *);
  594. extern template _CRTIMP basic_istream<char, char_traits<char> >& __cdecl operator>>(
  595.        basic_istream<char, char_traits<char> >&, unsigned char&);
  596. extern template _CRTIMP basic_istream<wchar_t, char_traits<wchar_t> >& __cdecl operator>>(
  597.        basic_istream<wchar_t, char_traits<wchar_t> >&, wchar_t *);
  598. extern template _CRTIMP basic_istream<wchar_t, char_traits<wchar_t> >& __cdecl operator>>(
  599.        basic_istream<wchar_t, char_traits<wchar_t> >&, wchar_t&);
  600. extern template _CRTIMP basic_istream<wchar_t, char_traits<wchar_t> >& __cdecl operator>>(
  601.        basic_istream<wchar_t, char_traits<wchar_t> >&, signed short *);
  602.  
  603. #pragma warning(default:4231) /* restore previous warning */
  604. #endif        // _DLL
  605.  
  606.  
  607. _STD_END
  608. #ifdef  _MSC_VER
  609. #pragma pack(pop)
  610. #endif  /* _MSC_VER */
  611.  
  612. #endif /* _ISTREAM_ */
  613.  
  614. /*
  615.  * Copyright (c) 1994 by P.J. Plauger.  ALL RIGHTS RESERVED. 
  616.  * Consult your license regarding permissions and restrictions.
  617.  */
  618.