home *** CD-ROM | disk | FTP | other *** search
/ Tricks of the Windows Gam…ming Gurus (2nd Edition) / Disc2.iso / vc98 / crt / src / istream < prev    next >
Text File  |  1998-06-16  |  18KB  |  630 lines
  1. // istream standard header
  2.  
  3. #if     _MSC_VER > 1000 /*IFSTRIP=IGN*/
  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. #ifdef __FORCE_INSTANCE
  427. template class _CRTIMP2 basic_istream<char, char_traits<char> >;
  428. template class _CRTIMP2 basic_istream<wchar_t, char_traits<wchar_t> >;
  429. #else        // __FORCE_INSTANCE
  430. #pragma warning(disable:4231) /* the extern before template is a non-standard extension */
  431. extern template class _CRTIMP2 basic_istream<char, char_traits<char> >;
  432. extern template class _CRTIMP2 basic_istream<wchar_t, char_traits<wchar_t> >;
  433. #pragma warning(default:4231) /* restore previous warning */
  434. #endif        // __FORCE_INSTANCE
  435. #endif        // _DLL
  436.  
  437.         // TEMPLATE CLASS basic_iostream
  438. template<class _E, class _Tr = char_traits<_E> >
  439.     class basic_iostream : public basic_istream<_E, _Tr>,
  440.         public basic_ostream<_E, _Tr> {
  441. public:
  442.     explicit basic_iostream(basic_streambuf<_E, _Tr> *_S)
  443.         : basic_istream<_E, _Tr>(_S), basic_ostream<_E, _Tr>(_S, false, false)
  444.         {}
  445.     virtual ~basic_iostream()
  446.         {}
  447.     };
  448.  
  449. #ifdef _DLL
  450. #ifdef __FORCE_INSTANCE
  451. template class _CRTIMP2 basic_iostream<char, char_traits<char> >;
  452. template class _CRTIMP2 basic_iostream<wchar_t, char_traits<wchar_t> >;
  453. #else        // __FORCE_INSTANCE
  454. #pragma warning(disable:4231) /* the extern before template is a non-standard extension */
  455. extern template class _CRTIMP2 basic_iostream<char, char_traits<char> >;
  456. extern template class _CRTIMP2 basic_iostream<wchar_t, char_traits<wchar_t> >;
  457. #pragma warning(default:4231) /* restore previous warning */
  458. #endif        // __FORCE_INSTANCE
  459. #endif        // _DLL
  460.  
  461.  
  462.  
  463.         // EXTRACTORS
  464. template<class _E, class _Tr> inline
  465.     basic_istream<_E, _Tr>& __cdecl operator>>(
  466.         basic_istream<_E, _Tr>& _I, _E *_X)
  467.     {typedef basic_istream<_E, _Tr> _Myis;
  468.     typedef ctype<_E> _Ctype;
  469.     ios_base::iostate _St = ios_base::goodbit;
  470.     _E *_S = _X;
  471.     const _Myis::sentry _Ok(_I);
  472.     if (_Ok)
  473.         {const _Ctype& _Fac = _USE(_I.getloc(), _Ctype);
  474.         _TRY_IO_BEGIN
  475.         int _N = 0 < _I.width() ? _I.width() : INT_MAX;
  476.         _Myis::int_type _C = _I.rdbuf()->sgetc();
  477.         for (; 0 < --_N; _C = _I.rdbuf()->snextc())
  478.             if (_Tr::eq_int_type(_Tr::eof(), _C))
  479.                 {_St |= ios_base::eofbit;
  480.                 break; }
  481.             else if (_Fac.is(_Ctype::space,
  482.                 _Tr::to_char_type(_C)))
  483.                 break;
  484.             else
  485.                 *_S++ = _Tr::to_char_type(_C);
  486.         _CATCH_IO_(_I) }
  487.     *_S = _E(0);
  488.     _I.width(0);
  489.     _I.setstate(_S == _X ? _St | ios_base::failbit : _St);
  490.     return (_I); }
  491. template<class _E, class _Tr> inline
  492.     basic_istream<_E, _Tr>& __cdecl operator>>(
  493.         basic_istream<_E, _Tr>& _I, _E& _X)
  494.     {typedef basic_istream<_E, _Tr> _Myis;
  495.     _Myis::int_type _C;
  496.     ios_base::iostate _St = ios_base::goodbit;
  497.     const _Myis::sentry _Ok(_I);
  498.     if (_Ok)
  499.         {_TRY_IO_BEGIN
  500.         _C = _I.rdbuf()->sbumpc();
  501.         if (_Tr::eq_int_type(_Tr::eof(), _C))
  502.             _St |= ios_base::eofbit | ios_base::failbit;
  503.         else
  504.             _X = _Tr::to_char_type(_C);
  505.         _CATCH_IO_(_I) }
  506.     _I.setstate(_St);
  507.     return (_I); }
  508. template<class _E, class _Tr> inline
  509.     basic_istream<_E, _Tr>& __cdecl operator>>(
  510.         basic_istream<_E, _Tr>& _I, signed char *_X)
  511.     {return (_I >> (char *)_X); }
  512. template<class _E, class _Tr> inline
  513.     basic_istream<_E, _Tr>& __cdecl operator>>(
  514.         basic_istream<_E, _Tr>& _I, signed char& _C)
  515.     {return (_I >> (char&)_C); }
  516. template<class _E, class _Tr> inline
  517.     basic_istream<_E, _Tr>& __cdecl operator>>(
  518.         basic_istream<_E, _Tr>& _I, unsigned char *_X)
  519.     {return (_I >> (char *)_X); }
  520. template<class _E, class _Tr> inline
  521.     basic_istream<_E, _Tr>& __cdecl operator>>(
  522.         basic_istream<_E, _Tr>& _I, unsigned char& _C)
  523.     {return (_I >> (char&)_C); }
  524. template<class _E, class _Tr> inline
  525.     basic_istream<_E, _Tr>& __cdecl operator>>(
  526.         basic_istream<_E, _Tr>& _I, signed short * _X)
  527.     {return (_I >> (wchar_t *)_X); }
  528.         // MANIPULATORS
  529. template<class _E, class _Tr> inline
  530.     basic_istream<_E, _Tr>& __cdecl ws(basic_istream<_E, _Tr>& _I)
  531.     {typedef basic_istream<_E, _Tr> _Myis;
  532.     typedef ctype<_E> _Ctype;
  533.     ios_base::iostate _St = ios_base::goodbit;
  534.     const _Myis::sentry _Ok(_I, true);
  535.     if (_Ok)
  536.         {const _Ctype& _Fac = _USE(_I.getloc(), _Ctype);
  537.         _TRY_IO_BEGIN
  538.         for (_Tr::int_type _C = _I.rdbuf()->sgetc(); ;
  539.             _C = _I.rdbuf()->snextc())
  540.             if (_Tr::eq_int_type(_Tr::eof(), _C))
  541.                 {_St |= ios_base::eofbit;
  542.                 break; }
  543.             else if (!_Fac.is(_Ctype::space,
  544.                 _Tr::to_char_type(_C)))
  545.                 break;
  546.         _CATCH_IO_(_I) }
  547.     _I.setstate(_St);
  548.     return (_I); }
  549. _CRTIMP2 inline basic_istream<char, char_traits<char> >&
  550.     __cdecl ws(basic_istream<char, char_traits<char> >& _I)
  551.     {typedef char _E;
  552.     typedef char_traits<_E> _Tr;
  553.     ios_base::iostate _St = ios_base::goodbit;
  554.     const basic_istream<_E, _Tr>::sentry _Ok(_I, true);
  555.     if (_Ok)
  556.         {const ctype<_E>& _Fac = _USE(_I.getloc(), ctype<_E>);
  557.         _TRY_IO_BEGIN
  558.         for (_Tr::int_type _C = _I.rdbuf()->sgetc(); ;
  559.             _C = _I.rdbuf()->snextc())
  560.             if (_Tr::eq_int_type(_Tr::eof(), _C))
  561.                 {_St |= ios_base::eofbit;
  562.                 break; }
  563.             else if (!_Fac.is(ctype<_E>::space,
  564.                 _Tr::to_char_type(_C)))
  565.                 break;
  566.         _CATCH_IO_(_I) }
  567.     _I.setstate(_St);
  568.     return (_I); }
  569. _CRTIMP2 inline basic_istream<wchar_t, char_traits<wchar_t> >&
  570.     __cdecl ws(basic_istream<wchar_t, char_traits<wchar_t> >& _I)
  571.     {typedef wchar_t _E;
  572.     typedef char_traits<_E> _Tr;
  573.     ios_base::iostate _St = ios_base::goodbit;
  574.     const basic_istream<_E, _Tr>::sentry _Ok(_I, true);
  575.     if (_Ok)
  576.         {const ctype<_E>& _Fac = _USE(_I.getloc(), ctype<_E>);
  577.         _TRY_IO_BEGIN
  578.         for (_Tr::int_type _C = _I.rdbuf()->sgetc(); ;
  579.             _C = _I.rdbuf()->snextc())
  580.             if (_Tr::eq_int_type(_Tr::eof(), _C))
  581.                 {_St |= ios_base::eofbit;
  582.                 break; }
  583.             else if (_Fac.is(ctype<_E>::space,
  584.                 _Tr::to_char_type(_C)))
  585.                 break;
  586.         _CATCH_IO_(_I) }
  587.     _I.setstate(_St);
  588.     return (_I); }
  589.  
  590.  
  591. #ifdef _DLL
  592. #ifndef CRTDLL2
  593. #pragma warning(disable:4231) /* the extern before template is a non-standard extension */
  594.  
  595. extern template _CRTIMP2 basic_istream<char, char_traits<char> >& __cdecl operator>>(
  596.        basic_istream<char, char_traits<char> >&, char *);
  597. extern template _CRTIMP2 basic_istream<char, char_traits<char> >& __cdecl operator>>(
  598.        basic_istream<char, char_traits<char> >&, char&);
  599. extern template _CRTIMP2 basic_istream<char, char_traits<char> >& __cdecl operator>>(
  600.        basic_istream<char, char_traits<char> >&, signed char *);
  601. extern template _CRTIMP2 basic_istream<char, char_traits<char> >& __cdecl operator>>(
  602.        basic_istream<char, char_traits<char> >&, signed char&);
  603. extern template _CRTIMP2 basic_istream<char, char_traits<char> >& __cdecl operator>>(
  604.        basic_istream<char, char_traits<char> >&, unsigned char *);
  605. extern template _CRTIMP2 basic_istream<char, char_traits<char> >& __cdecl operator>>(
  606.        basic_istream<char, char_traits<char> >&, unsigned char&);
  607. extern template _CRTIMP2 basic_istream<wchar_t, char_traits<wchar_t> >& __cdecl operator>>(
  608.        basic_istream<wchar_t, char_traits<wchar_t> >&, wchar_t *);
  609. extern template _CRTIMP2 basic_istream<wchar_t, char_traits<wchar_t> >& __cdecl operator>>(
  610.        basic_istream<wchar_t, char_traits<wchar_t> >&, wchar_t&);
  611. extern template _CRTIMP2 basic_istream<wchar_t, char_traits<wchar_t> >& __cdecl operator>>(
  612.        basic_istream<wchar_t, char_traits<wchar_t> >&, signed short *);
  613.  
  614. #pragma warning(default:4231) /* restore previous warning */
  615. #endif        // CRTDLL2
  616. #endif        // _DLL
  617.  
  618.  
  619. _STD_END
  620. #ifdef  _MSC_VER
  621. #pragma pack(pop)
  622. #endif  /* _MSC_VER */
  623.  
  624. #endif /* _ISTREAM_ */
  625.  
  626. /*
  627.  * Copyright (c) 1994 by P.J. Plauger.  ALL RIGHTS RESERVED. 
  628.  * Consult your license regarding permissions and restrictions.
  629.  */
  630.