Click above to get retro games delivered to your door ever month!

class istream : virtual public ios {
public:
        // constructor and destructor
        _Cdecl istream(streambuf*);
virtual _Cdecl ~istream();

        // Obsolete constructors, for streams 1.2 compatibility
                // obsolete: set skip via format, tie via tie() function
        _Cdecl istream(streambuf*, int _sk, ostream* _t=0);
                // obsolete: use strstream
        _Cdecl istream(int _sz, char*, int _sk=1);
                // obsolete: use fstream
        _Cdecl istream(int _fd, int _sk=1, ostream* _t=0);

        int _Cdecl ipfx(int = 0);       // input prefix function
        int _Cdecl ipfx0();     // same as ipfx(0)
        int _Cdecl ipfx1();     // same as ipfx(1)
        void _Cdecl isfx()      { } // unused input suffix function

        // set/read the get pointer's position
    istream& _Cdecl seekg(streampos);
    istream& _Cdecl seekg(streamoff, seek_dir);
    streampos _Cdecl tellg();

    int _Cdecl sync();

        /*
         * Unformatted extraction operations
         */
        // extract characters into an array
    istream& _Cdecl get(  signed char*, int, char = '\n');
    istream& _Cdecl get(unsigned char*, int, char = '\n');
    istream& _Cdecl read(  signed char*, int);
    istream& _Cdecl read(unsigned char*, int);

        // extract characters into an array up to termination char
    istream& _Cdecl getline(  signed char*, int, signed char = '\n');
    istream& _Cdecl getline(unsigned char*, int, signed char = '\n');

        // extract characters into a streambuf up to termination char
    istream& _Cdecl get(streambuf&, char = '\n');

        // extract a single character
    istream& _Cdecl get(unsigned char&);
    istream& _Cdecl get(  signed char&);
    int      _Cdecl get();

        int      _Cdecl peek();     // return next char without extraction
        int      _Cdecl gcount();   // number of unformatted chars last extracted
        istream& _Cdecl putback(char);  // push back char into input

        // extract and discard chars but stop at delim
    istream& _Cdecl ignore(int = 1, int = EOF);

        /*
         * Formatted extraction operations
         */
    istream& _Cdecl operator>> (istream& (*_f)(istream&));
    istream& _Cdecl operator>> (ios& (*_f)(ios&) );
    istream& _Cdecl operator>> (  signed char*);
    istream& _Cdecl operator>> (unsigned char*);
    istream& _Cdecl operator>> (unsigned char&);


    istream& _Cdecl operator>> (  signed char&);
    istream& _Cdecl operator>> (short&);
    istream& _Cdecl operator>> (int&);
    istream& _Cdecl operator>> (long&);
    istream& _Cdecl operator>> (unsigned short&);
    istream& _Cdecl operator>> (unsigned int&);
    istream& _Cdecl operator>> (unsigned long&);
    istream& _Cdecl operator>> (float&);
    istream& _Cdecl operator>> (double&);
    istream& _Cdecl operator>> (long double&);

        // extract from this istream, insert into streambuf
    istream& _Cdecl operator>> (streambuf*);

protected:
            _Cdecl istream();
        int     _Cdecl do_ipfx(int);    // implementation of ipfx
        void    _Cdecl eatwhite();      // extract consecutive whitespace

private:
        int gcount_;    // chars extracted by last unformatted operation
        signed char _Cdecl do_get();    // implementation of get
};
inline int  _Cdecl istream::gcount() { return gcount_; }
inline int  _Cdecl istream::ipfx(int _need) {
                if( _need ? (ispecial & ~skipping) : ispecial )
                    return do_ipfx(_need);
                return 1;
                }
inline int  _Cdecl istream::ipfx0() { return ispecial ? do_ipfx(0) : 1; }
inline int  _Cdecl istream::ipfx1() {
                return (ispecial & ~skipping) ? do_ipfx(1) : 1;
                }
#ifdef _BIG_INLINE_
inline istream& _Cdecl istream::operator>> (unsigned char& _c) {
                if( ipfx0() )
                    _c = bp->in_avail() ? bp->sbumpc() : do_get();
                return *this;
                }
inline istream& _Cdecl istream::operator>> (signed char& _c) {
                if( ipfx0() )
                    _c = bp->in_avail() ? bp->sbumpc() : do_get();
                return *this;
                }
#endif
inline istream& _Cdecl istream::operator>> (unsigned char* _p) {
                return *this >> (signed char *)_p;
                }
inline istream& _Cdecl istream::get(unsigned char* _p, int _l, char _t) {
                return get((signed char*)_p, _l, _t);
                }
inline istream& _Cdecl istream::read(unsigned char* _p, int _l) {
                return read((signed char*)_p, _l);
                }
inline istream& _Cdecl istream::getline(
                        unsigned char* _p, int _l, signed char _t)
                        { return getline((signed char*) _p, _l, _t);
                }
inline int      _Cdecl istream::sync() { return bp->sync(); }
inline istream& _Cdecl istream::operator>> (istream& (*_f) (istream&)) {
                return (*_f)(*this);
                }
#ifdef _BIG_INLINE_
inline istream& _Cdecl istream::get(unsigned char& _c) {


                if( ipfx1() )
                    if( bp->in_avail() ) {
                        gcount_ = 1;
                        _c = bp->sbumpc();
                    }
                else _c = do_get();
                return *this;
                }
inline istream& _Cdecl istream::get(signed char& _c) {
                if( ipfx1() )
                    if( bp->in_avail()) {
                        gcount_ = 1;
                        _c = bp->sbumpc();
                    }
                else _c = do_get();
                return *this;
                }
inline int      _Cdecl istream::get() {
                if( ipfx1() ) {
                    int _c = bp->sbumpc();
                    if( _c == EOF ) setstate(eofbit);
                    else gcount_ = 1;
                    return _c;
                }
                else return EOF;
                }
#endif
inline int  _Cdecl istream::peek() { return ipfx1() ? bp->sgetc() : EOF; }