gnu/lib/libg++/g++-include/File.h

   1 // This may look like C code, but it is really -*- C++ -*-
   2 /*
   3 Copyright (C) 1988 Free Software Foundation
   4     written by Doug Lea (dl@rocky.oswego.edu)
   5
   6 This file is part of GNU CC.
   7
   8 GNU CC is distributed in the hope that it will be useful,
   9 but WITHOUT ANY WARRANTY.  No author or distributor
  10 accepts responsibility to anyone for the consequences of using it
  11 or for whether it serves any particular purpose or works at all,
  12 unless he says so in writing.  Refer to the GNU CC General Public
  13 License for full details.
  14
  15 Everyone is granted permission to copy, modify and redistribute
  16 GNU CC, but only under the conditions described in the
  17 GNU CC General Public License.   A copy of this license is
  18 supposed to have been given to you along with GNU CC so you
  19 can know your rights and responsibilities.  It should be in a
  20 file named COPYING.  Among other things, the copyright notice
  21 and this notice must be preserved on all copies.
  22 */
  23
  24 #ifndef _File_h
  25 #ifdef __GNUG__
  26 #pragma once
  27 #pragma interface
  28 #endif
  29 #define _File_h 1
  30
  31 #include <builtin.h>
  32 #include <stdio.h>
  33 #include <stddef.h>
  34
  35 #include <Fmodes.h>
  36
  37 class Filebuf;
  38
  39 class File
  40 {
  41   friend class  Filebuf;
  42 protected:
  43   FILE*         fp;              // _iobuf file pointer
  44   char*         nm;              // file name (dynamically allocated)
  45   char          rw;              //  1 = read; 2 = write; 3 = readwrite
  46                                  //  bit 2 (4) means read/write into string
  47   state_value   state;           // _good/_eof/_fail/_bad
  48   long          stat;            // last read/write/... return value
  49
  50   void          initialize();
  51   void          reinitialize(const char*);
  52   char         *readline (int chunk_number, char terminator);
  53
  54 public:
  55                 File();
  56                 File(const char* filename, io_mode m, access_mode a);
  57                 File(const char* filename, const char* m);
  58                 File(int filedesc, io_mode m);
  59                 File(FILE* fileptr);
  60                 File(int sz, char* buf, io_mode m);
  61
  62                 ~File();
  63
  64 // binding, rebinding, unbinding to physical files
  65
  66   File&         open(const char* filename, io_mode m, access_mode a);
  67   File&         open(const char* filename, const char* m);
  68   File&         open(int  filedesc, io_mode m);
  69   File&         open(FILE* fileptr);
  70
  71   File&         close();
  72   File&         remove();
  73
  74 // class variable access
  75
  76   int           filedesc();
  77   const char*   name();
  78   void          setname(const char* newname);
  79   int           iocount();
  80
  81   int           rdstate();
  82   int           eof();
  83   int           fail();
  84   int           bad();
  85   int           good();
  86
  87 // other status queries
  88
  89   int           readable();
  90   int           writable();
  91   int           is_open();
  92
  93                 operator void*();
  94
  95 // error handling
  96
  97   void          error();
  98   void          clear(state_value f = _good); // poorly named
  99   void          set(state_value f); // set corresponding but
 100   void          unset(state_value f); // clear corresponding bit
 101   File&         failif(int cond);
 102   void          check_state();
 103
 104 // character IO
 105
 106   File&         get(char& c);
 107   File&         put(char  c);
 108   File&         unget(char c);
 109   File&         putback(char c); // a synonym for unget
 110
 111 // char* IO
 112
 113   File&         put(const char* s);
 114   File&         get    (char* s, int n, char terminator = '\n');
 115   File&         getline(char* s, int n, char terminator = '\n');
 116   File&         gets   (char **s, char terminator = '\n');
 117
 118 // binary IO
 119
 120   File&         read(void* x, int sz, int n);
 121   File&         write(void* x, int sz, int n);
 122
 123 // formatted IO
 124
 125   File&         form(const char* ...);
 126   File&         scan(const char* ...);
 127
 128 // buffer IO
 129
 130   File&         flush();
 131
 132 // position control
 133
 134   File&         seek(long pos, int seek_mode=0); // default seek mode=absolute
 135   long          tell();
 136
 137 // buffer control
 138
 139   File&         setbuf(int buffer_kind); // legal vals: _IONBF, _IOFBF, _IOLBF
 140   File&         setbuf(int size, char* buf);
 141   File&         raw();
 142 };
 143
 144
 145 // error handlers
 146
 147 extern void  verbose_File_error_handler(const char*);
 148 extern void  quiet_File_error_handler(const char*);
 149 extern void  fatal_File_error_handler(const char*);
 150 extern one_arg_error_handler_t File_error_handler;
 151 extern one_arg_error_handler_t set_File_error_handler(one_arg_error_handler_t);
 152
 153 #if defined(__OPTIMIZE__) || defined(USE_LIBGXX_INLINES)
 154
 155
 156
 157 inline int File::filedesc()
 158 {
 159   return fileno(fp);
 160 }
 161
 162 inline const char* File::name()
 163 {
 164   return nm;
 165 }
 166
 167 inline int File::iocount()
 168 {
 169   return stat;
 170 }
 171
 172 inline void File::clear(state_value flag)
 173 {
 174   state = flag;
 175 }
 176
 177 inline void File::set(state_value flag)
 178 {
 179   state = state_value(int(state) | int(flag));
 180 }
 181
 182 inline void File::unset(state_value flag)
 183 {
 184   state = state_value(int(state) & ~int(flag));
 185 }
 186
 187 inline int File::readable()
 188 {
 189   if (fp != 0) { if (feof(fp)) set(_eof); if (ferror(fp)) set(_bad);}
 190   return (state == _good && (rw & 01));
 191 }
 192
 193 inline int File::writable()
 194 {
 195   if (fp != 0 && ferror(fp)) set(_bad);
 196   return ((int(state) & (int(_fail)|int(_bad))) == 0 && (rw & 02));
 197 }
 198
 199 inline int File::is_open()
 200 {
 201   return (fp != 0);
 202 }
 203
 204
 205 inline File& File::raw()
 206 {
 207   return this->File::setbuf(_IONBF);
 208 }
 209
 210
 211 inline File& File::failif(int cond)
 212 {
 213   if (cond) set(_fail);  return *this;
 214 }
 215
 216 inline File& File::get(char& c)
 217 {
 218   if (readable())
 219   {
 220     int ch = getc(fp);
 221     c = ch;
 222     failif (ch == EOF);
 223   }
 224   return *this;
 225 }
 226
 227 inline File& File::put(char  c)
 228 {
 229   return failif (!writable() ||  putc(c, fp) == EOF);
 230 }
 231
 232 inline File& File::unget(char c)
 233 {
 234   return failif(!is_open() || !(rw & 01) || ungetc(c, fp) == EOF);
 235 }
 236
 237 inline File& File::putback(char c)
 238 {
 239   return failif (!is_open() || !(rw & 01) || ungetc(c, fp) == EOF);
 240 }
 241
 242 inline File& File::read(void* x, int sz, int n)
 243 {
 244   return failif (!readable() || (stat = fread(x, sz, n, fp)) != n);
 245 }
 246
 247 inline File& File::write(void* x, int sz, int n)
 248 {
 249   return failif (!writable() || (stat = fwrite(x, sz, n, fp)) != n);
 250 }
 251
 252 inline File& File::flush()
 253 {
 254   return failif(!is_open() || fflush(fp) == EOF);
 255 }
 256
 257
 258 inline File& File::seek(long pos, int seek_mode)
 259 {
 260   return failif (!is_open() || fseek(fp, pos, seek_mode) < 0);
 261 }
 262
 263 inline long File::tell()
 264 {
 265   failif (!is_open() || ((stat = ftell(fp)) < 0));
 266   return stat;
 267 }
 268
 269 inline int File::rdstate()
 270 {
 271   check_state();  return state; // check_state is necessary in rare but
 272 }                               // possible circumstances
 273
 274 inline File::operator void*()
 275 {
 276   check_state();  return (int(state) & (int(_bad)|int(_fail)))? 0 : this ;
 277 }
 278
 279 inline int File::eof()
 280 {
 281   check_state(); return state & _eof;
 282 }
 283
 284 inline int File::fail()
 285 {
 286   check_state(); return state & _fail;
 287 }
 288
 289 inline int File::bad()
 290 {
 291   check_state(); return state & _bad;
 292 }
 293
 294 inline int File::good()
 295 {
 296   check_state(); return rdstate() == _good;
 297 }
 298
 299
 300 #endif
 301
 302 #endif