build: add the SIBO SDK
This commit is contained in:
@@ -0,0 +1,700 @@
|
||||
/* Release 3.10 */
|
||||
/*-------------------------------------------------------------------------*
|
||||
* *
|
||||
* IOSTREAM.HPP - header file for stream input and output. *
|
||||
* *
|
||||
* COPYRIGHT (C) 1990..1992 Clarion Software Corporation *
|
||||
* All Rights Reserved *
|
||||
* *
|
||||
*--------------------------------------------------------------------------*/
|
||||
#include <stdepoc.h>
|
||||
|
||||
#ifndef _IOSTREAM_INC_
|
||||
#define _IOSTREAM_INC_
|
||||
|
||||
#include <mem.h>
|
||||
|
||||
#ifdef EOF
|
||||
#if EOF != -1
|
||||
#undef EOF
|
||||
#define EOF (-1)
|
||||
#endif
|
||||
#else
|
||||
#define EOF (-1)
|
||||
#endif
|
||||
|
||||
#define zapeof(c) ((c)&0xFF)
|
||||
|
||||
typedef long streampos;
|
||||
typedef long streamoff;
|
||||
|
||||
class streambuf;
|
||||
class ostream;
|
||||
|
||||
class ios {
|
||||
|
||||
public:
|
||||
enum io_state {
|
||||
goodbit = 0x00,
|
||||
eofbit = 0x01,
|
||||
failbit = 0x02,
|
||||
badbit = 0x04,
|
||||
hardfail = 0x80
|
||||
};
|
||||
|
||||
enum open_mode {
|
||||
in = 0x01,
|
||||
out = 0x02,
|
||||
ate = 0x04,
|
||||
app = 0x08,
|
||||
trunc = 0x10,
|
||||
nocreate = 0x20,
|
||||
noreplace = 0x40,
|
||||
binary = 0x80
|
||||
};
|
||||
|
||||
enum seek_dir {
|
||||
beg=0,
|
||||
cur=1,
|
||||
end=2
|
||||
};
|
||||
|
||||
enum {
|
||||
skipws = 0x0001,
|
||||
left = 0x0002,
|
||||
right = 0x0004,
|
||||
internal = 0x0008,
|
||||
dec = 0x0010,
|
||||
oct = 0x0020,
|
||||
hex = 0x0040,
|
||||
showbase = 0x0080,
|
||||
showpoint = 0x0100,
|
||||
uppercase = 0x0200,
|
||||
showpos = 0x0400,
|
||||
scientific = 0x0800,
|
||||
fixed = 0x1000,
|
||||
unitbuf = 0x2000,
|
||||
stdio = 0x4000
|
||||
};
|
||||
|
||||
static const long basefield;
|
||||
static const long adjustfield;
|
||||
static const long floatfield;
|
||||
|
||||
ios(streambuf* _buffer);
|
||||
virtual ~ios();
|
||||
|
||||
long flags();
|
||||
long flags(long _fl);
|
||||
long setf(long _setbits, long _fld);
|
||||
long setf(long _fld);
|
||||
long unsetf(long _fld);
|
||||
|
||||
int width();
|
||||
int width(int _w);
|
||||
|
||||
char fill();
|
||||
char fill(char _f);
|
||||
|
||||
int precision();
|
||||
int precision(int _p);
|
||||
|
||||
ostream* tie();
|
||||
ostream* tie(ostream* _ost);
|
||||
|
||||
int rdstate();
|
||||
int eof();
|
||||
int fail();
|
||||
int bad();
|
||||
int good();
|
||||
void clear(int = 0);
|
||||
operator void* ();
|
||||
int operator! ();
|
||||
streambuf* rdbuf();
|
||||
|
||||
static long bitalloc();
|
||||
static int xalloc();
|
||||
long& iword(int);
|
||||
void*& pword(int);
|
||||
|
||||
static void sync_with_stdio();
|
||||
|
||||
int skip(int);
|
||||
|
||||
protected:
|
||||
|
||||
enum {
|
||||
translate = 0x080,
|
||||
skipping = 0x100,
|
||||
tied = 0x200
|
||||
};
|
||||
|
||||
streambuf *_bp;
|
||||
ostream* x_tie;
|
||||
int state;
|
||||
int ispecial;
|
||||
int ospecial;
|
||||
long x_flags;
|
||||
int x_precision;
|
||||
int x_width;
|
||||
int x_fill;
|
||||
int isfx_special;
|
||||
int osfx_special;
|
||||
int delbuf;
|
||||
int assign_private;
|
||||
|
||||
ios();
|
||||
void init(streambuf* _buffer);
|
||||
void setstate(int);
|
||||
static void (*stdioflush)();
|
||||
|
||||
private:
|
||||
|
||||
union ios_user_union {
|
||||
long x;
|
||||
void *p;
|
||||
};
|
||||
|
||||
static long nextbit;
|
||||
static int usercount;
|
||||
union ios_user_union *userwords;
|
||||
int nwords;
|
||||
void uresize(int);
|
||||
|
||||
ios(ios&); // not implemented
|
||||
void operator= (ios&); // not implemented
|
||||
};
|
||||
|
||||
#ifdef _SMALL_INLINE
|
||||
inline streambuf* ios::rdbuf() { return _bp;}
|
||||
inline ostream* ios::tie() { return x_tie;}
|
||||
inline char ios::fill() { return x_fill; }
|
||||
inline int ios::precision() { return x_precision; }
|
||||
inline int ios::rdstate() { return state; }
|
||||
inline int ios::eof() { return (state&eofbit); }
|
||||
inline int ios::fail() { return (state&(failbit|badbit|hardfail)); }
|
||||
inline int ios::bad() { return (state&(badbit|hardfail)); }
|
||||
inline int ios::good() { return (state == 0); }
|
||||
inline long ios::flags() { return x_flags; }
|
||||
inline int ios::width() { return x_width; }
|
||||
inline int ios::width(int _w) { int _temp = x_width;
|
||||
x_width = _w;
|
||||
return _temp; }
|
||||
inline char ios::fill(char _w) { char _temp = x_fill;
|
||||
x_fill = _w;
|
||||
return _temp; }
|
||||
inline int ios::precision(int _w) { int _temp = x_precision;
|
||||
x_precision = _w;
|
||||
return _temp; }
|
||||
|
||||
inline ios::operator void* () {return (fail()|eof()) ? 0 : this; }
|
||||
inline ios::operator! () {return (fail()|eof()); }
|
||||
#endif
|
||||
|
||||
|
||||
class streambuf {
|
||||
|
||||
public:
|
||||
|
||||
streambuf();
|
||||
streambuf(char * _buf, int _size);
|
||||
virtual ~streambuf();
|
||||
|
||||
virtual streambuf* setbuf(char * _buf, int _size);
|
||||
virtual streambuf* setbuf(char * _buf, int , int);
|
||||
|
||||
int sgetc();
|
||||
int snextc();
|
||||
int sbumpc();
|
||||
void stossc();
|
||||
int sgetn(char *_s, int _num);
|
||||
virtual int do_sgetn(char *_s, int _num);
|
||||
virtual int underflow();
|
||||
int sputbackc(char _c);
|
||||
virtual int pbackfail(int);
|
||||
int in_avail();
|
||||
|
||||
int sputc(int _c);
|
||||
virtual int do_sputn(const char *_s, int _num);
|
||||
int sputn(const char *_s, int _num);
|
||||
virtual int overflow(int _c = EOF);
|
||||
int out_waiting();
|
||||
|
||||
virtual streampos seekoff(streamoff, ios::seek_dir, int = (ios::in | ios::out));
|
||||
virtual streampos seekpos(streamoff, int = (ios::in | ios::out));
|
||||
virtual int sync();
|
||||
int dbp();
|
||||
|
||||
protected:
|
||||
|
||||
char *base();
|
||||
char *ebuf();
|
||||
int blen();
|
||||
char *pbase();
|
||||
char *pptr();
|
||||
char *epptr();
|
||||
char *eback();
|
||||
char *gptr();
|
||||
char *egptr();
|
||||
void setp(char *, char *);
|
||||
void setg(char *, char *, char *);
|
||||
void pbump(int);
|
||||
void gbump(int);
|
||||
void setb(char *, char *, int = 0);
|
||||
void unbuffered(int);
|
||||
int unbuffered();
|
||||
int allocate();
|
||||
virtual int doallocate();
|
||||
|
||||
private:
|
||||
short _alloc;
|
||||
short _unbuf;
|
||||
char *_base;
|
||||
char *_ebuf;
|
||||
char *_pbase;
|
||||
char *_pptr;
|
||||
char *_epptr;
|
||||
char *_eback;
|
||||
char *_gptr;
|
||||
char *_egptr;
|
||||
|
||||
streambuf(streambuf&);
|
||||
void operator= (streambuf&);
|
||||
|
||||
int do_snextc();
|
||||
};
|
||||
#ifdef _SMALL_INLINE
|
||||
inline char * streambuf::base() { return _base; }
|
||||
inline char * streambuf::pbase() { return _pbase; }
|
||||
inline char * streambuf::pptr() { return _pptr; }
|
||||
inline char * streambuf::epptr() { return _epptr; }
|
||||
inline char * streambuf::gptr() { return _gptr; }
|
||||
inline char * streambuf::egptr() { return _egptr; }
|
||||
inline char * streambuf::eback() { return _eback; }
|
||||
inline char * streambuf::ebuf() { return _ebuf; }
|
||||
|
||||
inline int streambuf::unbuffered() { return _unbuf; }
|
||||
inline int streambuf::blen() { return (int) (_ebuf - _base); }
|
||||
|
||||
inline void streambuf::pbump(int _n) { _pptr += _n; }
|
||||
inline void streambuf::gbump(int _n) { _gptr += _n; }
|
||||
inline void streambuf::unbuffered(int _ub) { _unbuf = (_ub != 0); }
|
||||
inline int streambuf::in_avail() { return (_egptr > _gptr) ?
|
||||
(int)(_egptr - _gptr): 0; }
|
||||
inline int streambuf::out_waiting() { return _pptr ?
|
||||
(int)(_pptr - _pbase): 0; }
|
||||
inline int streambuf::allocate() { return((_base || _unbuf) ? 0 : doallocate()); }
|
||||
|
||||
inline int streambuf::sgetc() { return ((_gptr >= _egptr) ? underflow() :
|
||||
(unsigned char) *_gptr); }
|
||||
|
||||
inline int streambuf::snextc() { return ((++_gptr >= _egptr) ?
|
||||
do_snextc() :
|
||||
(unsigned char) *_gptr); }
|
||||
|
||||
inline int streambuf::sbumpc() { return ((_gptr >= _egptr)
|
||||
&& (underflow() == EOF) ?
|
||||
EOF :
|
||||
(unsigned char) *_gptr++); }
|
||||
inline void streambuf::stossc() { if (_gptr >= _egptr)
|
||||
underflow();
|
||||
else
|
||||
++_gptr; }
|
||||
|
||||
inline int streambuf::sputbackc(char _c) { return (_gptr > _eback) ?
|
||||
*--_gptr = _c :
|
||||
pbackfail(_c) ; }
|
||||
|
||||
inline int streambuf::sputc(int _c) { return (_pptr >= _epptr) ?
|
||||
overflow(_c) :
|
||||
(*_pptr++=_c, _c); }
|
||||
|
||||
#ifdef _BIG_INLINE
|
||||
inline int streambuf::sputn(const char *_s, int _n) {
|
||||
if(_n <= (_epptr - _pptr)) {
|
||||
memcpy(_pptr, _s, _n);
|
||||
pbump(_n);
|
||||
return _n;
|
||||
}
|
||||
return do_sputn(_s, _n); }
|
||||
|
||||
inline int streambuf::sgetn(char *_s, int _n) {
|
||||
if(_n <= (_egptr - _gptr)) {
|
||||
memcpy(_s, _gptr, _n);
|
||||
gbump(_n);
|
||||
return _n;
|
||||
}
|
||||
return do_sgetn(_s, _n); }
|
||||
|
||||
#endif
|
||||
#endif
|
||||
class istream : virtual public ios {
|
||||
|
||||
public:
|
||||
|
||||
istream(streambuf*);
|
||||
istream(streambuf*, int _sk, ostream* _t=NULL);
|
||||
istream(int _sz, char *, int _sk=1);
|
||||
istream(int _fd, int _sk=1, ostream* _t=NULL);
|
||||
virtual ~istream();
|
||||
|
||||
int ipfx(int = 0);
|
||||
int ipfx0();
|
||||
int ipfx1();
|
||||
void isfx() {}
|
||||
|
||||
istream& seekg(streampos);
|
||||
istream& seekg(streamoff, ios::seek_dir);
|
||||
streampos tellg();
|
||||
|
||||
int sync();
|
||||
|
||||
istream& get( signed char*, int, char = '\n');
|
||||
istream& get(unsigned char*, int, char = '\n');
|
||||
istream& get( char*, int, char = '\n');
|
||||
istream& read( signed char*, int);
|
||||
istream& read(unsigned char*, int);
|
||||
istream& read( char*, int);
|
||||
istream& getline( signed char*, int, char = '\n');
|
||||
istream& getline(unsigned char*, int, char = '\n');
|
||||
istream& getline( char*, int, char = '\n');
|
||||
|
||||
istream& get(streambuf&, char = '\n');
|
||||
istream& get( signed char&);
|
||||
istream& get(unsigned char&);
|
||||
istream& get( char&);
|
||||
int get();
|
||||
|
||||
int peek();
|
||||
int gcount();
|
||||
istream& putback(char);
|
||||
istream& ignore(int = 1, int = EOF);
|
||||
|
||||
istream& operator>> (istream& (*_f)(istream&));
|
||||
istream& operator>> (ios& (*_f)(ios&));
|
||||
istream& operator>> ( signed char*);
|
||||
istream& operator>> (unsigned char*);
|
||||
istream& operator>> ( char*);
|
||||
istream& operator>> ( signed char&);
|
||||
istream& operator>> (unsigned char&);
|
||||
istream& operator>> ( char&);
|
||||
istream& operator>> (short&);
|
||||
istream& operator>> (int&);
|
||||
istream& operator>> (long&);
|
||||
istream& operator>> (unsigned short&);
|
||||
istream& operator>> (unsigned int&);
|
||||
istream& operator>> (unsigned long&);
|
||||
istream& operator>> (float&);
|
||||
istream& operator>> (double&);
|
||||
istream& operator>> (long double&);
|
||||
|
||||
istream& operator>> (streambuf*);
|
||||
|
||||
protected:
|
||||
|
||||
istream();
|
||||
int do_ipfx(int);
|
||||
void eatwhite();
|
||||
|
||||
private:
|
||||
|
||||
int _gcount;
|
||||
int do_get();
|
||||
};
|
||||
|
||||
#ifdef _SMALL_INLINE
|
||||
inline int istream::gcount() { return _gcount; }
|
||||
|
||||
inline int istream::ipfx(int _need) { if( _need ? (ispecial&~skipping) :
|
||||
ispecial)
|
||||
return do_ipfx(_need);
|
||||
return 1; }
|
||||
|
||||
inline int istream::ipfx0() { return ispecial ? do_ipfx(0) : 1; }
|
||||
|
||||
inline int istream::ipfx1() { return (ispecial&~skipping) ? do_ipfx(1) : 1; }
|
||||
|
||||
inline istream& istream::operator>>(unsigned char& _c) {
|
||||
if(ipfx0()) {
|
||||
if(_bp->in_avail())
|
||||
_c = _bp->sbumpc();
|
||||
else
|
||||
_c = do_get();
|
||||
}
|
||||
return *this; }
|
||||
|
||||
inline istream& istream::operator>>(signed char& _c) {
|
||||
if(ipfx0()) {
|
||||
if(_bp->in_avail())
|
||||
_c = _bp->sbumpc();
|
||||
else
|
||||
_c = do_get();
|
||||
}
|
||||
return *this; }
|
||||
|
||||
inline istream& istream::operator>>( char& _c) {
|
||||
if(ipfx0()) {
|
||||
if(_bp->in_avail())
|
||||
_c = _bp->sbumpc();
|
||||
else
|
||||
_c = do_get();
|
||||
}
|
||||
return *this; }
|
||||
|
||||
inline istream& istream::operator>>(unsigned char* _s) {
|
||||
return *this>>(signed char *) _s; }
|
||||
|
||||
inline istream& istream::operator>>( char* _s) {
|
||||
return *this>>(signed char *) _s; }
|
||||
|
||||
inline istream& istream::get(unsigned char* _s, int _l, char _t) {
|
||||
return get((signed char *)_s, _l, _t); }
|
||||
|
||||
inline istream& istream::get( char* _s, int _l, char _t) {
|
||||
return get((signed char *)_s, _l, _t); }
|
||||
|
||||
#ifdef _BIG_INLINE_
|
||||
inline istream& istream::get(unsigned char& _c) {
|
||||
if( ipfx1() ) {
|
||||
if( _bp->in_avail() ) {
|
||||
_gcount = 1;
|
||||
_c = _bp->sbumpc();
|
||||
}
|
||||
else
|
||||
_c = do_get();
|
||||
}
|
||||
return *this; }
|
||||
|
||||
inline istream& istream::get(signed char& _c) {
|
||||
if( ipfx1() ) {
|
||||
if( _bp->in_avail()) {
|
||||
_gcount = 1;
|
||||
_c = _bp->sbumpc();
|
||||
}
|
||||
else
|
||||
_c = do_get();
|
||||
}
|
||||
return *this; }
|
||||
|
||||
|
||||
inline istream& istream::get( char& _c) {
|
||||
if( ipfx1() ) {
|
||||
if( _bp->in_avail()) {
|
||||
_gcount = 1;
|
||||
_c = _bp->sbumpc();
|
||||
}
|
||||
else
|
||||
_c = do_get();
|
||||
}
|
||||
return *this; }
|
||||
|
||||
inline int istream::get() {
|
||||
if( ipfx1() ) {
|
||||
int _c = _bp->sbumpc();
|
||||
if( _c == EOF )
|
||||
setstate(eofbit);
|
||||
else _gcount = 1;
|
||||
return _c;
|
||||
}
|
||||
return EOF; }
|
||||
|
||||
#endif
|
||||
|
||||
inline istream& istream::read(unsigned char* _s, int _l) {
|
||||
return read((signed char *)_s, _l); }
|
||||
|
||||
inline istream& istream::read( char* _s, int _l) {
|
||||
return read((signed char *)_s, _l); }
|
||||
|
||||
inline istream& istream::getline(unsigned char* _s, int _l, char _t) {
|
||||
return getline((signed char *)_s, _l, _t); }
|
||||
|
||||
inline istream& istream::getline( char* _s, int _l, char _t) {
|
||||
return getline((signed char *)_s, _l, _t); }
|
||||
|
||||
inline int istream::sync() { return _bp->sync(); }
|
||||
|
||||
inline istream& istream::operator>> (istream& (*_f)(istream&)) {
|
||||
return (*_f)(*this); }
|
||||
|
||||
inline int istream::peek() { return ipfx1() ? _bp->sgetc() : EOF; }
|
||||
|
||||
#endif
|
||||
|
||||
class ostream : virtual public ios {
|
||||
|
||||
public:
|
||||
|
||||
|
||||
ostream(streambuf *);
|
||||
~ostream();
|
||||
|
||||
ostream(int _fd);
|
||||
ostream(int _sz, char *);
|
||||
|
||||
int opfx();
|
||||
void osfx();
|
||||
ostream& flush();
|
||||
|
||||
ostream& seekp(streampos);
|
||||
ostream& seekp(streamoff, ios::seek_dir);
|
||||
streampos tellp();
|
||||
|
||||
ostream& put(char);
|
||||
ostream& write(const char*, int);
|
||||
ostream& write(const signed char*, int);
|
||||
ostream& write(const unsigned char*, int);
|
||||
|
||||
ostream& operator<<( signed char);
|
||||
ostream& operator<<(unsigned char);
|
||||
ostream& operator<<( char);
|
||||
ostream& operator<<( signed short);
|
||||
ostream& operator<<(unsigned short);
|
||||
ostream& operator<<( signed int);
|
||||
ostream& operator<<(unsigned int);
|
||||
ostream& operator<<( signed long);
|
||||
ostream& operator<<(unsigned long);
|
||||
ostream& operator<<(float);
|
||||
ostream& operator<<(double);
|
||||
ostream& operator<<(long double);
|
||||
ostream& operator<<(const char *);
|
||||
ostream& operator<<(const signed char *);
|
||||
ostream& operator<<(const unsigned char *);
|
||||
ostream& operator<<(void *);
|
||||
|
||||
ostream& operator<<(streambuf*);
|
||||
ostream& operator<<(ostream& (*_f)(ostream&));
|
||||
ostream& operator<<(ios& (*_f)(ios&));
|
||||
|
||||
protected:
|
||||
|
||||
ostream();
|
||||
int do_opfx();
|
||||
int do_osfx();
|
||||
|
||||
private:
|
||||
|
||||
void outlong(unsigned long, int);
|
||||
void outstr(const char *);
|
||||
};
|
||||
|
||||
#ifdef _SMALL_INLINE
|
||||
inline int ostream::opfx() { return ospecial ? do_opfx() : 1; }
|
||||
|
||||
inline void ostream::osfx() { if((x_flags&(stdio|unitbuf)) || (ospecial)) do_osfx(); }
|
||||
|
||||
inline ostream& ostream::operator<<(unsigned char _c) {
|
||||
return *this <<(signed char ) _c; }
|
||||
|
||||
inline ostream& ostream::operator<<( char _c) {
|
||||
return *this <<(signed char ) _c; }
|
||||
|
||||
inline ostream& ostream::operator<<(short _i) { return *this<<(long)_i; }
|
||||
|
||||
inline ostream& ostream::operator<<(unsigned short _i) {
|
||||
return *this<<(unsigned long)_i; }
|
||||
|
||||
inline ostream& ostream::operator<<(int _i) { return *this<<(long)_i; }
|
||||
|
||||
inline ostream& ostream::operator<<(unsigned int _i) {
|
||||
return *this<<(unsigned long)_i; }
|
||||
|
||||
inline ostream& ostream::operator<<(float _f) {
|
||||
return *this<<(long double)_f; }
|
||||
|
||||
inline ostream& ostream::operator<<(double _f) {
|
||||
return *this<<(long double)_f; }
|
||||
|
||||
inline ostream& ostream::operator<<(ostream& (*_f)(ostream&)) {
|
||||
return (*_f)(*this); }
|
||||
|
||||
inline ostream& ostream::write(const signed char *_s, int _n) {
|
||||
return write((const char *)_s, _n); }
|
||||
|
||||
inline ostream& ostream::write(const unsigned char *_s, int _n) {
|
||||
return write((const char *)_s, _n); }
|
||||
|
||||
inline ostream& ostream::put(char _c) {
|
||||
if(_bp->sputc(_c) == EOF)
|
||||
setstate(badbit);
|
||||
return *this; }
|
||||
|
||||
inline ostream& ostream::operator<<(const signed char *_s) {
|
||||
return *this<<(const char *) _s; }
|
||||
|
||||
inline ostream& ostream::operator<<(const unsigned char *_s) {
|
||||
return *this<<(const char *) _s; }
|
||||
#endif
|
||||
|
||||
class iostream : public istream , public ostream {
|
||||
|
||||
public:
|
||||
|
||||
iostream(streambuf*);
|
||||
virtual ~iostream();
|
||||
|
||||
protected:
|
||||
iostream();
|
||||
|
||||
};
|
||||
|
||||
|
||||
class istream_withassign : public istream {
|
||||
|
||||
public:
|
||||
|
||||
istream_withassign();
|
||||
virtual ~istream_withassign();
|
||||
|
||||
istream_withassign& operator= (istream&);
|
||||
istream_withassign& operator= (streambuf*);
|
||||
|
||||
private:
|
||||
|
||||
unsigned assign_const;
|
||||
};
|
||||
|
||||
class ostream_withassign : public ostream {
|
||||
|
||||
public:
|
||||
|
||||
ostream_withassign();
|
||||
virtual ~ostream_withassign();
|
||||
|
||||
ostream_withassign& operator= (ostream&);
|
||||
ostream_withassign& operator= (streambuf*);
|
||||
|
||||
private:
|
||||
|
||||
unsigned assign_const;
|
||||
};
|
||||
|
||||
class iostream_withassign : public iostream {
|
||||
|
||||
public:
|
||||
|
||||
iostream_withassign();
|
||||
virtual ~iostream_withassign();
|
||||
|
||||
iostream_withassign& operator= (ios&);
|
||||
iostream_withassign& operator= (streambuf*);
|
||||
|
||||
private:
|
||||
|
||||
unsigned assign_const;
|
||||
};
|
||||
|
||||
extern istream_withassign cin;
|
||||
extern ostream_withassign cout;
|
||||
extern ostream_withassign cerr;
|
||||
extern ostream_withassign clog;
|
||||
|
||||
ostream& endl(ostream&);
|
||||
ostream& ends(ostream&);
|
||||
ostream& flush(ostream&);
|
||||
istream& ws(istream&);
|
||||
ios& dec(ios&);
|
||||
ios& hex(ios&);
|
||||
ios& oct(ios&);
|
||||
#endif
|
||||
|
||||
Reference in New Issue
Block a user