NetBSD/gnu/lib/libg++/g++-include/istream.h
1993-03-21 09:45:37 +00:00

260 lines
5.9 KiB
C++

// This may look like C code, but it is really -*- C++ -*-
/*
Copyright (C) 1989 Free Software Foundation
written by Doug Lea (dl@rocky.oswego.edu)
This file is part of GNU CC.
GNU CC is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY. No author or distributor
accepts responsibility to anyone for the consequences of using it
or for whether it serves any particular purpose or works at all,
unless he says so in writing. Refer to the GNU CC General Public
License for full details.
Everyone is granted permission to copy, modify and redistribute
GNU CC, but only under the conditions described in the
GNU CC General Public License. A copy of this license is
supposed to have been given to you along with GNU CC so you
can know your rights and responsibilities. It should be in a
file named COPYING. Among other things, the copyright notice
and this notice must be preserved on all copies.
*/
/* *** Version 1.2 -- nearly 100% AT&T 1.2 compatible *** */
/* istream.h now separately includable */
#ifndef _istream_h
#ifdef __GNUG__
#pragma once
#pragma interface
#endif
#define _istream_h 1
#include <File.h>
#include <streambuf.h>
#include <filebuf.h>
#include <Filebuf.h>
class whitespace // a class used only to input and
{ // discard white space characters
char filler;
};
class ostream;
class istream
{
friend void eatwhite(istream& s);
protected:
streambuf* bp;
state_value state; // _good/_eof/_fail/_bad
ostream* tied_to;
char skipws;
char ownbuf;
void _flush();
char* readline (int chunk_number, char terminator);
public:
istream(const char* filename, io_mode m, access_mode a,
int sk=1, ostream* t = 0);
istream(const char* filename, const char* m,
int sk=1, ostream* t = 0);
istream(int filedesc, io_mode m, int sk=1, ostream* t = 0);
istream(FILE* fileptr, int sk=1, ostream* t = 0);
istream(int sz, char* buf, int sk=1, ostream* t = 0);
istream(int filedesc, int sk=1, ostream* t = 0);
istream(int filedesc, char* buf, int buflen,
int sk, ostream* t = 0);
istream(streambuf* s, int sk=1, ostream* t = 0);
~istream();
istream& open(const char* filename, io_mode m, access_mode a);
istream& open(const char* filename, const char* m);
istream& open(int filedesc, io_mode m);
istream& open(FILE* fileptr);
istream& open(const char* filenam, open_mode m);
istream& close();
ostream* tie(ostream* s);
int skip(int);
// stream status
int rdstate();
int eof();
int fail();
int bad();
int good();
// other status queries
int readable();
int writable();
int is_open();
operator void*();
int operator !();
const char* name();
char* bufptr();
// error handling
void error();
void clear(state_value f = _good); // poorly named
void set(state_value f); // set corresponding bit
void unset(state_value f); // clear corresponding bit
istream& failif(int cond);
// unformatted IO
istream& get(char& c);
istream& unget(char c);
istream& putback(char c); // a synonym for unget
istream& get (char* s, int n, char terminator = '\n');
istream& getline(char* s, int n, char terminator = '\n');
istream& gets (char **s, char terminator = '\n');
istream& operator >> (char& c);
istream& operator >> (short& n);
istream& operator >> (unsigned short& n);
istream& operator >> (int& n);
istream& operator >> (unsigned int& n);
istream& operator >> (long& n);
istream& operator >> (unsigned long& n);
#ifdef __GNUG__
istream& operator >> (long long& n);
istream& operator >> (unsigned long long& n);
#endif
istream& operator >> (float& n);
istream& operator >> (double& n);
istream& operator >> (char* s);
istream& operator >> (whitespace& w);
};
// pre-declared streams
extern istream cin; // stdin
extern whitespace WS; // for convenience
#if defined(__OPTIMIZE__) || defined(USE_LIBGXX_INLINES)
inline void istream::clear(state_value flag)
{
state = flag;
}
inline void istream::set(state_value flag)
{
state = state_value(int(state) | int(flag));
}
inline void istream::unset(state_value flag)
{
state = state_value(int(state) & ~int(flag));
}
inline int istream::rdstate()
{
return int(state);
}
inline int istream::good()
{
return state == _good;
}
inline int istream::eof()
{
return int(state) & int(_eof);
}
inline int istream::fail()
{
return int(state) & int(_fail);
}
inline int istream::bad()
{
return int(state) & int(_bad);
}
inline istream::operator void*()
{
return (state == _good)? this : 0;
}
inline int istream::operator !()
{
return (state != _good);
}
inline istream& istream::failif(int cond)
{
if (cond) set(_fail); return *this;
}
inline int istream::is_open()
{
return bp->is_open();
}
inline int istream::readable()
{
return (bp != 0) && (bp->is_open()) && (state == _good);
}
inline int istream::writable()
{
return 0;
}
inline char* istream::bufptr()
{
return bp->base;
}
inline istream& istream::close()
{
bp->close(); return *this;
}
inline int istream::skip(int sk)
{
int was = skipws; skipws = sk; return was;
}
inline istream& istream::unget(char c)
{
if (bp->sputbackc(c) == EOF) set(_fail); return *this;
}
inline istream& istream::putback(char c)
{
if (bp->sputbackc(c) == EOF) set(_fail); return *this;
}
inline void eatwhite(istream& s)
{
s >> WS;
}
#endif
#endif