home *** CD-ROM | disk | FTP | other *** search
/ GEMini Atari / GEMini_Atari_CD-ROM_Walnut_Creek_December_1993.iso / files / gnu / g__inc / xfile.h < prev    next >
Encoding:
C/C++ Source or Header  |  1993-07-23  |  8.2 KB  |  371 lines
  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 the GNU C++ Library.  This library is free
  7. software; you can redistribute it and/or modify it under the terms of
  8. the GNU Library General Public License as published by the Free
  9. Software Foundation; either version 2 of the License, or (at your
  10. option) any later version.  This library is distributed in the hope
  11. that it will be useful, but WITHOUT ANY WARRANTY; without even the
  12. implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  13. PURPOSE.  See the GNU Library General Public License for more details.
  14. You should have received a copy of the GNU Library General Public
  15. License along with this library; if not, write to the Free Software
  16. Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  17. */
  18.  
  19. #ifndef _File_h 
  20. #ifdef __GNUG__
  21. #pragma once
  22. #pragma interface
  23. #endif
  24. #define _File_h 1
  25.  
  26. #include <builtin.h>
  27. #include <stdio.h>
  28. #include <stddef.h>
  29.  
  30. #include <xfmodes.h>
  31.  
  32. class Filebuf;
  33.  
  34. class File
  35. {
  36.   friend class  Filebuf;
  37. protected:
  38.   FILE*         fp;              // _iobuf file pointer
  39.   char*         nm;              // file name (dynamically allocated)
  40.   char          rw;              //  1 = read; 2 = write; 3 = readwrite
  41.                                  //  bit 2 (4) means read/write into string
  42.   state_value   state;           // _good/_eof/_fail/_bad
  43.   long          stat;            // last read/write/... return value
  44.  
  45.   void          initialize();
  46.   void          reinitialize(const char*);
  47.   char         *readline (int chunk_number, char terminator);
  48.  
  49. public:
  50.                 File();
  51.                 File(const char* filename, io_mode m, access_mode a);
  52.                 File(const char* filename, const char* m);   
  53.                 File(int filedesc, io_mode m);
  54.                 File(FILE* fileptr);
  55. #ifdef atarist
  56.                 File(size_t sz, char* buf, io_mode m);
  57. #else
  58.                 File(int sz, char* buf, io_mode m);
  59. #endif
  60.                 ~File();
  61.  
  62. // binding, rebinding, unbinding to physical files
  63.  
  64.   File&         open(const char* filename, io_mode m, access_mode a);
  65.   File&         open(const char* filename, const char* m);
  66.   File&         open(int  filedesc, io_mode m);
  67.   File&         open(FILE* fileptr);
  68.  
  69.   File&         close();
  70.   File&         remove();
  71.  
  72. // class variable access
  73.  
  74.   int           filedesc();
  75.   const char*   name();
  76.   void          setname(const char* newname);
  77.   long          iocount();    /* outright wrong in orig */
  78.  
  79.   int           rdstate();
  80.   int           eof();
  81.   int           fail();
  82.   int           bad();
  83.   int           good();
  84. #ifdef atarist
  85.   int           bin();
  86.   int           text();
  87. #endif
  88.  
  89. // other status queries
  90.  
  91.   int           readable();
  92.   int           writable();
  93.   int           is_open();
  94.  
  95.                 operator void*();
  96.  
  97. // error handling
  98.  
  99.   void          error();
  100.   void          clear(state_value f = _good); // poorly named
  101.   void          set(state_value f); // set corresponding but
  102.   void          unset(state_value f); // clear corresponding bit
  103.   File&         failif(int cond);
  104.   void          check_state();
  105.  
  106. // character IO
  107.  
  108.   File&         get(char& c);
  109.   File&         put(char  c);
  110.   File&         unget(char c);
  111.   File&         putback(char c); // a synonym for unget
  112.  
  113. // char* IO
  114.  
  115.   File&         put(const char* s);
  116.   File&         get    (char* s, int n, char terminator = '\n');
  117.   File&         getline(char* s, int n, char terminator = '\n');
  118.   File&         gets   (char **s, char terminator = '\n');
  119.  
  120. // binary IO
  121.  
  122. #ifdef atarist
  123.   File&         read(void* x, size_t sz, size_t n);
  124.   File&         write(void* x, size_t sz, size_t n);
  125. #else
  126.   File&         read(void* x, int sz, int n);
  127.   File&         write(void* x, int sz, int n);
  128. #endif
  129.  
  130. // formatted IO
  131.  
  132.   File&         form(const char* ...);
  133.   File&         scan(const char* ...);
  134.  
  135. // buffer IO
  136.  
  137.   File&         flush();
  138.   File&         flush(char ch); // call stdio _flsbuf
  139.   int           fill();         // call stdio _filbuf
  140.  
  141. // position control
  142.  
  143.   File&         seek(long pos, int seek_mode=0); // default seek mode=absolute
  144.   long          tell();
  145.  
  146. // buffer control
  147.  
  148.   File&         setbuf(int buffer_kind); // legal vals: _IONBF, _IOFBF, _IOLBF
  149. #ifdef atarist
  150.   File&         setbuf(size_t size, char* buf);
  151. #else
  152.   File&         setbuf(int size, char* buf);
  153. #endif
  154.   File&         raw();
  155. };
  156.  
  157.  
  158. // error handlers
  159.  
  160. extern void  verbose_File_error_handler(const char*);
  161. extern void  quiet_File_error_handler(const char*);
  162. extern void  fatal_File_error_handler(const char*);
  163. extern one_arg_error_handler_t File_error_handler;
  164. extern one_arg_error_handler_t set_File_error_handler(one_arg_error_handler_t);
  165.  
  166. #if defined(__OPTIMIZE__) || defined(USE_LIBGXX_INLINES)
  167.  
  168.  
  169.  
  170. inline int File::filedesc()
  171. { 
  172.   return fileno(fp);
  173. }
  174.  
  175. inline const char* File::name()
  176. { 
  177.   return nm; 
  178. }
  179.  
  180. inline long File::iocount()
  181. { 
  182.   return stat; 
  183. }
  184.  
  185. inline void File::clear(state_value flag)
  186. { 
  187.   state = flag;
  188. }
  189.  
  190. inline void File::set(state_value flag)
  191. { 
  192.   state = state_value(int(state) | int(flag));
  193. }
  194.  
  195. inline void File::unset(state_value flag)
  196. { 
  197.   state = state_value(int(state) & ~int(flag));
  198. }
  199.  
  200. inline int File::readable()
  201. { 
  202.   if (fp != 0) { if (feof(fp)) set(_eof); if (ferror(fp)) set(_bad);}
  203. #ifndef atarist
  204.   return (state == _good && (rw & 01));
  205. #else
  206.   return (state_value(rdstate()) == _good && (rw & 01));
  207. #endif
  208. }
  209.  
  210. inline int File::writable()
  211. { 
  212.   if (fp != 0 && ferror(fp)) set(_bad);
  213.   return ((int(state) & (int(_fail)|int(_bad))) == 0 && (rw & 02));
  214. }
  215.  
  216. inline int File::is_open()
  217. { 
  218.   return (fp != 0);
  219. }
  220.  
  221.  
  222. inline File& File::raw()
  223. { 
  224.   return this->File::setbuf(_IONBF); 
  225. }
  226.  
  227.  
  228. inline File& File::failif(int cond)
  229. { 
  230.   if (cond) set(_fail);  return *this; 
  231. }
  232.  
  233. inline File& File::get(char& c)
  234. { 
  235.   if (readable())
  236.   {
  237.     int ch = getc(fp);
  238.     c = ch;
  239.     failif (ch == EOF);
  240.   }
  241.   return *this;
  242. }
  243.  
  244. inline File& File::put(char  c) 
  245. { 
  246.   return failif (!writable() ||  putc(c, fp) == EOF);
  247. }
  248.  
  249. inline File& File::unget(char c)
  250. { 
  251.   return failif(!is_open() || !(rw & 01) || ungetc(c, fp) == EOF);
  252. } 
  253.  
  254. inline File& File::putback(char c)
  255. { 
  256.   return failif (!is_open() || !(rw & 01) || ungetc(c, fp) == EOF);
  257. }
  258.  
  259. #ifdef atarist
  260. inline File& File::read(void* x, size_t sz, size_t n)
  261. { 
  262.   return failif (!readable() || (stat = fread(x, sz, n, fp)) != n);
  263. } 
  264.  
  265. inline File& File::write(void* x, size_t sz, size_t n) 
  266. { 
  267.   return failif (!writable() || (stat = fwrite(x, sz, n, fp)) != n);
  268. }
  269. #else
  270. inline File& File::read(void* x, int sz, int n)
  271. { 
  272.   return failif (!readable() || (stat = fread(x, sz, n, fp)) != n);
  273. } 
  274.  
  275. inline File& File::write(void* x, int sz, int n) 
  276. { 
  277.   return failif (!writable() || (stat = fwrite(x, sz, n, fp)) != n);
  278. }
  279. #endif
  280.  
  281. inline File& File::flush()
  282. { 
  283.   return failif(!is_open() || fflush(fp) == EOF);
  284. }
  285.  
  286. inline File& File::flush(char ch)
  287. { 
  288. #ifdef VMS
  289.   return failif(!is_open() || c$$flsbuf(ch, fp) == EOF);
  290. #else
  291. #ifdef atarist
  292.   return failif(!is_open() || fputc(ch, fp) == EOF || fflush(fp) == EOF);
  293. #else
  294.   return failif(!is_open() || _flsbuf(ch, fp) == EOF);
  295. #endif
  296. #endif
  297. }
  298.  
  299. inline int File::fill()
  300. { 
  301. #ifdef VMS
  302.   failif(!is_open() || (stat = c$$filbuf(fp)) == EOF);
  303. #else
  304.   failif(!is_open() || (stat = _filbuf(fp)) == EOF);
  305. #endif
  306.   return stat;
  307. }
  308.  
  309. inline File& File::seek(long pos, int seek_mode)
  310. { 
  311.   return failif (!is_open() || fseek(fp, pos, seek_mode) < 0); 
  312. }
  313.  
  314. inline long File::tell()
  315. { 
  316.   failif (!is_open() || ((stat = ftell(fp)) < 0));
  317.   return stat;
  318. }
  319.  
  320. inline int File::rdstate()
  321. { 
  322. #ifndef atarist
  323.   check_state();  return state; // check_state is necessary in rare but
  324. }                               // possible circumstances
  325. #else
  326.   check_state(); return (state & ~(_bin|_text));
  327. }
  328. #endif
  329.  
  330. inline File::operator void*()
  331. { 
  332.   check_state();  return (int(state) & (int(_bad)|int(_fail)))? 0 : this ; 
  333. }
  334.  
  335. inline int File::eof()
  336. { 
  337.   check_state(); return state & _eof; 
  338. }
  339.  
  340. inline int File::fail()
  341. { 
  342.   check_state(); return state & _fail; 
  343. }
  344.  
  345. inline int File::bad()
  346. { 
  347.   check_state(); return state & _bad; 
  348. }
  349.  
  350. inline int File::good()
  351. { 
  352.   check_state(); return rdstate() == _good; 
  353. }
  354.  
  355. #ifdef atarist
  356.  
  357. inline int File::bin()
  358. {
  359.   check_state(); return state & _bin;
  360. }
  361.  
  362. inline int File::text()
  363. {
  364.   check_state(); return state & _text;
  365. }
  366. #endif  // atarist
  367.  
  368. #endif
  369.  
  370. #endif
  371.