diff options
| author | cgd <cgd@NetBSD.org> | 1993-03-21 09:45:37 +0000 |
|---|---|---|
| committer | cgd <cgd@NetBSD.org> | 1993-03-21 09:45:37 +0000 |
| commit | 61f282557f0bc41c0b762c629a2f4c14be8b7591 (patch) | |
| tree | 38dac9066415c3d9887f4b1e4500d13ee1aae777 /gnu/lib/libg++/g++-include/File.h | |
| parent | a50e92ee94fef5ef9c87e87efc192c0a3f75f06e (diff) | |
initial import of 386bsd-0.1 sources
Diffstat (limited to 'gnu/lib/libg++/g++-include/File.h')
| -rw-r--r-- | gnu/lib/libg++/g++-include/File.h | 302 |
1 files changed, 302 insertions, 0 deletions
diff --git a/gnu/lib/libg++/g++-include/File.h b/gnu/lib/libg++/g++-include/File.h new file mode 100644 index 00000000000..ce9dbef8bf0 --- /dev/null +++ b/gnu/lib/libg++/g++-include/File.h @@ -0,0 +1,302 @@ +// This may look like C code, but it is really -*- C++ -*- +/* +Copyright (C) 1988 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. +*/ + +#ifndef _File_h +#ifdef __GNUG__ +#pragma once +#pragma interface +#endif +#define _File_h 1 + +#include <builtin.h> +#include <stdio.h> +#include <stddef.h> + +#include <Fmodes.h> + +class Filebuf; + +class File +{ + friend class Filebuf; +protected: + FILE* fp; // _iobuf file pointer + char* nm; // file name (dynamically allocated) + char rw; // 1 = read; 2 = write; 3 = readwrite + // bit 2 (4) means read/write into string + state_value state; // _good/_eof/_fail/_bad + long stat; // last read/write/... return value + + void initialize(); + void reinitialize(const char*); + char *readline (int chunk_number, char terminator); + +public: + File(); + File(const char* filename, io_mode m, access_mode a); + File(const char* filename, const char* m); + File(int filedesc, io_mode m); + File(FILE* fileptr); + File(int sz, char* buf, io_mode m); + + ~File(); + +// binding, rebinding, unbinding to physical files + + File& open(const char* filename, io_mode m, access_mode a); + File& open(const char* filename, const char* m); + File& open(int filedesc, io_mode m); + File& open(FILE* fileptr); + + File& close(); + File& remove(); + +// class variable access + + int filedesc(); + const char* name(); + void setname(const char* newname); + int iocount(); + + int rdstate(); + int eof(); + int fail(); + int bad(); + int good(); + +// other status queries + + int readable(); + int writable(); + int is_open(); + + operator void*(); + +// error handling + + void error(); + void clear(state_value f = _good); // poorly named + void set(state_value f); // set corresponding but + void unset(state_value f); // clear corresponding bit + File& failif(int cond); + void check_state(); + +// character IO + + File& get(char& c); + File& put(char c); + File& unget(char c); + File& putback(char c); // a synonym for unget + +// char* IO + + File& put(const char* s); + File& get (char* s, int n, char terminator = '\n'); + File& getline(char* s, int n, char terminator = '\n'); + File& gets (char **s, char terminator = '\n'); + +// binary IO + + File& read(void* x, int sz, int n); + File& write(void* x, int sz, int n); + +// formatted IO + + File& form(const char* ...); + File& scan(const char* ...); + +// buffer IO + + File& flush(); + +// position control + + File& seek(long pos, int seek_mode=0); // default seek mode=absolute + long tell(); + +// buffer control + + File& setbuf(int buffer_kind); // legal vals: _IONBF, _IOFBF, _IOLBF + File& setbuf(int size, char* buf); + File& raw(); +}; + + +// error handlers + +extern void verbose_File_error_handler(const char*); +extern void quiet_File_error_handler(const char*); +extern void fatal_File_error_handler(const char*); +extern one_arg_error_handler_t File_error_handler; +extern one_arg_error_handler_t set_File_error_handler(one_arg_error_handler_t); + +#if defined(__OPTIMIZE__) || defined(USE_LIBGXX_INLINES) + + + +inline int File::filedesc() +{ + return fileno(fp); +} + +inline const char* File::name() +{ + return nm; +} + +inline int File::iocount() +{ + return stat; +} + +inline void File::clear(state_value flag) +{ + state = flag; +} + +inline void File::set(state_value flag) +{ + state = state_value(int(state) | int(flag)); +} + +inline void File::unset(state_value flag) +{ + state = state_value(int(state) & ~int(flag)); +} + +inline int File::readable() +{ + if (fp != 0) { if (feof(fp)) set(_eof); if (ferror(fp)) set(_bad);} + return (state == _good && (rw & 01)); +} + +inline int File::writable() +{ + if (fp != 0 && ferror(fp)) set(_bad); + return ((int(state) & (int(_fail)|int(_bad))) == 0 && (rw & 02)); +} + +inline int File::is_open() +{ + return (fp != 0); +} + + +inline File& File::raw() +{ + return this->File::setbuf(_IONBF); +} + + +inline File& File::failif(int cond) +{ + if (cond) set(_fail); return *this; +} + +inline File& File::get(char& c) +{ + if (readable()) + { + int ch = getc(fp); + c = ch; + failif (ch == EOF); + } + return *this; +} + +inline File& File::put(char c) +{ + return failif (!writable() || putc(c, fp) == EOF); +} + +inline File& File::unget(char c) +{ + return failif(!is_open() || !(rw & 01) || ungetc(c, fp) == EOF); +} + +inline File& File::putback(char c) +{ + return failif (!is_open() || !(rw & 01) || ungetc(c, fp) == EOF); +} + +inline File& File::read(void* x, int sz, int n) +{ + return failif (!readable() || (stat = fread(x, sz, n, fp)) != n); +} + +inline File& File::write(void* x, int sz, int n) +{ + return failif (!writable() || (stat = fwrite(x, sz, n, fp)) != n); +} + +inline File& File::flush() +{ + return failif(!is_open() || fflush(fp) == EOF); +} + + +inline File& File::seek(long pos, int seek_mode) +{ + return failif (!is_open() || fseek(fp, pos, seek_mode) < 0); +} + +inline long File::tell() +{ + failif (!is_open() || ((stat = ftell(fp)) < 0)); + return stat; +} + +inline int File::rdstate() +{ + check_state(); return state; // check_state is necessary in rare but +} // possible circumstances + +inline File::operator void*() +{ + check_state(); return (int(state) & (int(_bad)|int(_fail)))? 0 : this ; +} + +inline int File::eof() +{ + check_state(); return state & _eof; +} + +inline int File::fail() +{ + check_state(); return state & _fail; +} + +inline int File::bad() +{ + check_state(); return state & _bad; +} + +inline int File::good() +{ + check_state(); return rdstate() == _good; +} + + +#endif + +#endif |
