home *** CD-ROM | disk | FTP | other *** search
/ GEMini Atari / GEMini_Atari_CD-ROM_Walnut_Creek_December_1993.iso / files / gnu / g__lib / file.old < prev    next >
Encoding:
Text File  |  1993-07-23  |  7.1 KB  |  310 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 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. #pragma once
  26. #define _File_h 1
  27.  
  28. #include <builtin.h>
  29. #include <stdio.h>
  30. #include <stddef.h>
  31.  
  32. enum io_mode                    // known unix file IO modes
  33. {
  34.   io_readonly   = 0,            
  35.   io_writeonly  = 1,
  36.   io_readwrite  = 2, 
  37.   io_appendonly = 3,
  38.   io_append     = 4,            // append, plus allow reads
  39. };
  40.  
  41. enum access_mode                // ways to open a file
  42. {
  43.   a_createonly  = 0,            // create, fail if file exists
  44.   a_create      = 1,            // create if doesn't exist, else truncate
  45.   a_useonly     = 2,            // use (no truncate)  fail if doesn't exist
  46.   a_use         = 3,            // use (no truncate), create if doesn't exist
  47. };
  48.  
  49. enum state_value                // File states
  50. { 
  51.   _good         = 0,            // all is well
  52.   _eof          = 1,            // at eof
  53.   _fail         = 2,            // logical or physical IO error
  54.   _bad          = 4             // unopened/corrupted
  55. };
  56.  
  57.  
  58. class File
  59. {
  60. protected:
  61.   FILE*         fp;              // _iobuf file pointer
  62.   char*         nm;              // file name (dynamically allocated)
  63.   char          rw;              //  1 = read; 2 = write; 3 = readwrite
  64.                                  //  bit 2 (4) means read/write into string
  65.   state_value   state;           // _good/_eof/_fail/_bad
  66.   long          stat;            // last read/write/... return value
  67.  
  68.   void          initialize();
  69.   void          reinitialize(const char*);
  70.   char         *readline (int chunk_number, char terminator);
  71.  
  72. public:
  73.                 File();
  74.                 File(const char* filename, io_mode m, access_mode a);
  75.                 File(const char* filename, const char* m);   
  76.                 File(int filedesc, io_mode m);
  77.                 File(FILE* fileptr);
  78.                 File(int sz, char* buf, io_mode m);
  79.  
  80.                 ~File();
  81.  
  82. // binding, rebinding, unbinding to physical files
  83.  
  84.   File&         open(const char* filename, io_mode m, access_mode a);
  85.   File&         open(const char* filename, const char* m);
  86.   File&         open(int  filedesc, io_mode m);
  87.   File&         open(FILE* fileptr);
  88.  
  89.   File&         close();
  90.   File&         remove();
  91.  
  92. // class variable access
  93.  
  94.   int           filedesc();
  95.   const char*   name();
  96.   void          setname(const char* newname);
  97.   int           iocount();
  98.  
  99.   int           rdstate();
  100.   int           eof();
  101.   int           fail();
  102.   int           bad();
  103.   int           good();
  104.  
  105. // other status queries
  106.  
  107.   int           readable();
  108.   int           writable();
  109.   int           is_open();
  110.  
  111.   void*         operator void*();
  112.  
  113. // error handling
  114.  
  115.   void          error();
  116.   void          clear(state_value f = 0); // poorly named
  117.   File&         failif(int cond);
  118.   void          check_state();
  119.  
  120. // character IO
  121.  
  122.   File&         get(char& c);
  123.   File&         put(char  c);
  124.   File&         unget(char c);
  125.   File&         putback(char c); // a synonym for unget
  126.  
  127. // char* IO
  128.  
  129.   File&         put(const char* s);
  130.   File&         get    (char* s, int n, char terminator = '\n');
  131.   File&         getline(char* s, int n, char terminator = '\n');
  132.   File&         gets   (char **s, char terminator = '\n');
  133.  
  134. // binary IO
  135.  
  136.   File&         read(void* x, int sz, int n);
  137.   File&         write(void* x, int sz, int n);
  138.  
  139.  
  140. // file control
  141.  
  142.   File&         seek(long pos, int seek_mode=0); // default seek mode=absolute
  143.   long          tell();
  144.  
  145.   File&         flush();
  146.   File&         setbuf(int buffer_kind); // legal vals: _IONBF, _IOFBF, _IOLBF
  147.   File&         setbuf(int size, char* buf);
  148.   File&         raw();
  149. };
  150.  
  151.  
  152. // error handlers
  153.  
  154. extern void  verbose_File_error_handler(char*);
  155. extern void  quiet_File_error_handler(char*);
  156. extern void  fatal_File_error_handler(char*);
  157. extern one_arg_error_handler_t File_error_handler;
  158. extern one_arg_error_handler_t set_File_error_handler(one_arg_error_handler_t);
  159.  
  160. //#ifdef __OPTIMIZE__
  161.  
  162.  
  163.  
  164. inline int File::filedesc()
  165. { 
  166.   return fileno(fp);
  167. }
  168.  
  169. inline const char* File::name()
  170. { 
  171.   return nm; 
  172. }
  173.  
  174. inline int File::iocount()
  175. { 
  176.   return stat; 
  177. }
  178.  
  179. inline int File::readable()
  180. { 
  181.   if (fp != 0) { if (feof(fp)) state |= _eof; if (ferror(fp)) state |= _bad;}
  182.   return (state == _good && (rw & 01));
  183. }
  184.  
  185. inline int File::writable()
  186. { 
  187.   if (fp != 0 && ferror(fp)) state |= _bad;
  188.   return ((state & (_fail|_bad)) == 0 && (rw & 02));
  189. }
  190.  
  191. inline int File::is_open()
  192. { 
  193.   return (fp != 0);
  194. }
  195.  
  196. inline void File::clear(state_value flag = 0)
  197. { 
  198.   state = flag;
  199. }
  200.  
  201. inline File& File::raw()
  202. { 
  203.   return this->File::setbuf(_IONBF); 
  204. }
  205.  
  206. inline void File::check_state() // ensure fp & state agree about eof
  207. {
  208.   if (fp != 0)
  209.   {
  210.     if (feof(fp))
  211.       state |= _eof;
  212.     else
  213.       state &= ~_eof;
  214.     if (ferror(fp))
  215.       state |= _bad;
  216.   }
  217. }
  218.  
  219. inline File& File::failif(int cond)
  220. { 
  221.   if (cond) state |= _fail;  return *this; 
  222. }
  223.  
  224. inline File& File::get(char& c)
  225. { 
  226.   if (readable())
  227.   {
  228.     int ch = getc(fp);
  229.     c = ch;
  230.     failif (ch == EOF);
  231.   }
  232.   return *this;
  233. }
  234.  
  235. inline File& File::put(char  c) 
  236. { 
  237.   return failif (!writable() ||  putc(c, fp) == EOF);
  238. }
  239.  
  240. inline File& File::unget(char c)
  241. { 
  242.   return failif(!is_open() || !(rw & 01) || ungetc(c, fp) == EOF);
  243. } 
  244.  
  245. inline File& File::putback(char c)
  246. { 
  247.   return failif (!is_open() || !(rw & 01) || ungetc(c, fp) == EOF);
  248. }
  249.  
  250. inline File& File::read(void* x, int sz, int n)
  251. { 
  252.   return failif (!readable() || (stat = fread(x, sz, n, fp)) != n);
  253. } 
  254.  
  255. inline File& File::write(void* x, int sz, int n) 
  256. { 
  257.   return failif (!writable() || (stat = fwrite(x, sz, n, fp)) != n);
  258. }
  259.  
  260. inline File& File::flush()
  261. { 
  262.   return failif(!is_open() || fflush(fp) == EOF);
  263. }
  264.  
  265. inline File& File::seek(long pos, int seek_mode = 0)
  266. { 
  267.   return failif (!is_open() || fseek(fp, pos, seek_mode) < 0); 
  268. }
  269.  
  270. inline long File::tell()
  271. { 
  272.   failif (!is_open() || (stat = ftell(fp) < 0));
  273.   return stat;
  274. }
  275.  
  276. inline int File::rdstate()
  277. { 
  278.   check_state();  return state; // check_state is necessary in rare but
  279. }                               // possible circumstances
  280.  
  281. inline void* File::operator void*()
  282. { 
  283.   check_state();  return (state & (_bad|_fail))? 0 : this ; 
  284. }
  285.  
  286. inline int File::eof()
  287. { 
  288.   check_state(); return state & _eof; 
  289. }
  290.  
  291. inline int File::fail()
  292. { 
  293.   check_state(); return state & _fail; 
  294. }
  295.  
  296. inline int File::bad()
  297. { 
  298.   check_state(); return state & _bad; 
  299. }
  300.  
  301. inline int File::good()
  302. { 
  303.   check_state(); return rdstate() == _good; 
  304. }
  305.  
  306.  
  307. //#endif
  308.  
  309. #endif
  310.