home *** CD-ROM | disk | FTP | other *** search
/ Liren Large Software Subsidy 7 / 07.iso / c / c017 / 7.ddi / GPPLIB.ZIP / FILE.CC < prev    next >
Encoding:
C/C++ Source or Header  |  1988-08-17  |  9.4 KB  |  479 lines
  1. /* 
  2. Copyright (C) 1988 Free Software Foundation
  3.     written by Doug Lea (dl@rocky.oswego.edu)
  4.  
  5. This file is part of GNU CC.
  6.  
  7. GNU CC is distributed in the hope that it will be useful,
  8. but WITHOUT ANY WARRANTY.  No author or distributor
  9. accepts responsibility to anyone for the consequences of using it
  10. or for whether it serves any particular purpose or works at all,
  11. unless he says so in writing.  Refer to the GNU CC General Public
  12. License for full details.
  13.  
  14. Everyone is granted permission to copy, modify and redistribute
  15. GNU CC, but only under the conditions described in the
  16. GNU CC General Public License.   A copy of this license is
  17. supposed to have been given to you along with GNU CC so you
  18. can know your rights and responsibilities.  It should be in a
  19. file named COPYING.  Among other things, the copyright notice
  20. and this notice must be preserved on all copies.  
  21. */
  22.  
  23. #include <File.h>
  24. #include <std.h>
  25. #include <stdarg.h>
  26. #include "libconfig.h"
  27.  
  28. #include <sys/file.h>           // needed to determine values of O_RDONLY...
  29.  
  30. #ifndef sun
  31. #include "/usr/include/fcntl.h"
  32. #endif
  33.  
  34.  
  35. // error handlers
  36.  
  37. void verbose_File_error_handler(char* msg)
  38. {
  39.   perror(msg);
  40.   errno = 0;
  41. }
  42.  
  43. void quiet_File_error_handler(char*)
  44. {
  45.   errno = 0;
  46. }
  47.  
  48. void fatal_File_error_handler(char* msg)
  49. {
  50.   perror(msg);
  51.   exit(1);
  52. }
  53.  
  54. one_arg_error_handler_t File_error_handler = verbose_File_error_handler;
  55.  
  56.  
  57. one_arg_error_handler_t set_File_error_handler(one_arg_error_handler_t f)
  58. {
  59.   one_arg_error_handler_t old = File_error_handler;
  60.   File_error_handler = f;
  61.   return old;
  62. }
  63.  
  64.  
  65. /*
  66.  
  67.  Opening files. 
  68.  
  69.  open(filename, io_mode, access_mode) is done via system open 
  70.  command since fopen doesn't handle all of the cases possible 
  71.  with sys open. After a successful open, fdopen is called to 
  72.  attach an _iobuf to the file descriptor.
  73.  
  74.  All this requires a few decoding routines that can translate among our
  75.  enumerated types, system flags, and fopen modes.
  76.  
  77. */
  78.  
  79.  
  80. enum sys_open_cmd_io_mode  // These should be correct for most systems
  81. {                        
  82.   sio_read      = O_RDONLY,
  83.   sio_write     = O_WRONLY,
  84.   sio_readwrite = O_RDWR,
  85.   sio_append    = O_APPEND
  86. };
  87.  
  88. enum sys_open_cmd_access_mode
  89. {
  90.   sa_create     = O_CREAT,
  91.   sa_truncate   = O_TRUNC,
  92.   sa_createonly = O_EXCL
  93. };
  94.  
  95.   
  96. static int open_cmd_arg(io_mode i, access_mode a) // decode modes
  97. {
  98.   int arg;
  99.   switch(i)
  100.   {
  101.   case io_readonly:   arg = sio_read;                   break;
  102.   case io_writeonly:  arg = sio_write;                  break;
  103.   case io_readwrite:  arg = sio_readwrite;              break;
  104.   case io_appendonly: arg = sio_append | sio_write;     break;
  105.   case io_append:     arg = sio_append | sio_readwrite; break;
  106.   default:            return -1;
  107.   };
  108.   switch(a)
  109.   {
  110.   case a_createonly:  return arg | sa_createonly;
  111.   case a_create:      return arg | sa_create | sa_truncate;
  112.   case a_useonly:     return arg;
  113.   case a_use:         return arg | sa_create;
  114.   default:            return -1;
  115.   }
  116. }
  117.  
  118. static char* fopen_cmd_arg(io_mode i)
  119. {
  120.   switch(i)
  121.   {
  122.   case io_readonly:  return "r";
  123.   case io_writeonly: return "w";
  124.   case io_readwrite: return "r+";
  125.   case io_appendonly:return "a";
  126.   case io_append:    return "a+";
  127.   default:           return 0;
  128.   }
  129. }
  130.  
  131.  
  132. void File::initialize() 
  133. { 
  134.   fp = 0; nm = 0; stat = 0; state = _bad; rw = 0;
  135. }
  136.  
  137. // reset class vars after open
  138. // fp->_flag inspection is isolated here
  139.  
  140. void File::reinitialize(const char* filename)
  141. {
  142.   if (filename != 0)     setname(filename);
  143.   else if (fp == stdin)  setname("(stdin)");
  144.   else if (fp == stdout) setname("(stdout)");
  145.   else if (fp == stderr) setname("(stderr)");
  146.   else setname(0);
  147.  
  148.   rw = 0;
  149.   if (fp != 0)
  150.   {
  151.     state = _good;
  152.     if (fp->_flag & (_IOREAD|_IORW))
  153.       rw |= 01;
  154.     if (fp->_flag & (_IOWRT|_IORW|_IOAPPEND))
  155.       rw |= 02;
  156.     check_state();
  157.   }
  158.   else
  159.   {
  160.     state = _fail|_bad;
  161.     error();
  162.   }
  163. }
  164.  
  165.  
  166. File& File::open(const char* filename, io_mode m, access_mode a)
  167. {                                   
  168.   close();
  169.   int open_arg = open_cmd_arg(m, a);
  170.   if (open_arg != -1)
  171.   {
  172.     int fd = ::open(filename, open_arg, 0666);
  173.     if (fd >= 0)
  174.       fp = fdopen(fd, fopen_cmd_arg(m));
  175.   }
  176.   reinitialize(filename);
  177.   return *this;
  178. }
  179.  
  180. File& File::open(const char* filename, const char* m)
  181. {                                   
  182.   close();
  183.   fp = fopen(filename, m);
  184.   reinitialize(filename);
  185.   return *this;
  186. }
  187.  
  188. File& File::open(FILE* fileptr)
  189. {
  190.   close();
  191.   fp = fileptr;
  192.   reinitialize(0);
  193.   return *this;
  194. }
  195.  
  196. File& File::open(int filedesc, io_mode m)
  197. {
  198.   close();
  199.   fp = fdopen(filedesc, fopen_cmd_arg(m));
  200.   reinitialize(0);
  201.   return *this;
  202. }
  203.  
  204. File& File::close()
  205. {
  206.   if (fp != 0)
  207.     fclose(fp);
  208.   fp = 0;
  209.   state = _bad;
  210.   return *this;
  211. }
  212.  
  213. File& File::remove()
  214. {
  215.   close();
  216.   return failif (nm == 0 || unlink(nm) != 0);
  217. }
  218.  
  219.  
  220. File::File()
  221. { 
  222.   initialize(); 
  223. }
  224.  
  225. File::File(const char* filename, io_mode m, access_mode a)   
  226. { 
  227.   initialize(); 
  228.   open(filename, m, a); 
  229. }
  230.  
  231. File::File(const char* filename, const char* m)   
  232. { 
  233.   initialize(); 
  234.   open(filename, m); 
  235. }
  236.  
  237. File::File(int filedesc, io_mode m)
  238. { 
  239.   initialize(); 
  240.   open(filedesc, m); 
  241. }
  242.  
  243. File::File(FILE* fileptr)
  244. { 
  245.   initialize(); 
  246.   open(fileptr); 
  247. }
  248.  
  249.  
  250. File::~File()
  251. {
  252.   delete(nm);
  253.   if (fp == stdin || fp == stdout || fp == stderr)
  254.     flush();
  255.   else if (fp != 0)
  256.     File::close();
  257. }
  258.  
  259. void File::setname(const char* newname)
  260. {
  261.   if (nm != 0)
  262.     delete(nm);
  263.   if (newname != 0)
  264.   {
  265.     nm = new char[strlen(newname) + 1];
  266.     strcpy(nm, newname);
  267.   }
  268.   else
  269.     nm = 0;
  270. }
  271.  
  272.  
  273. File& File::setbuf(int buffer_kind)
  274. {                  
  275.   if (!is_open())
  276.   {
  277.     error();
  278.     return *this;
  279.   }
  280.   switch(buffer_kind)
  281.   {
  282.   case _IOFBF:       
  283. #ifdef HAVE_SETVBUF
  284.     setvbuf(fp, 0, _IOFBF, 0);
  285. #endif
  286.     break;           
  287.   case _IONBF:       
  288.     ::setbuf(fp, 0); 
  289.     break;
  290.   case _IOLBF:
  291. #ifdef HAVE_SETLINEBUF
  292.     setlinebuf(fp);
  293. #else
  294. #ifdef HAVE_SETVBUF
  295.     setvbuf(fp, 0, _IOLBF, 0);
  296. #endif
  297. #endif    
  298.     break;
  299.   default:
  300.     break;
  301.   }
  302.   return *this;
  303. }
  304.  
  305. File& File::setbuf(int size, char* buf)
  306. {
  307.   if (!is_open())
  308.   {
  309.     error();
  310.     return *this;
  311.   }
  312. #ifdef HAVE_SETVBUF
  313.   setvbuf(fp, buf, _IOFBF, size);
  314. #else
  315.   setbuffer(fp, buf, size);
  316. #endif
  317.   return *this;
  318. }
  319.  
  320. void File::error()
  321. {
  322.   check_state();
  323.   state |= _fail;
  324.   if (errno != 0)
  325.   {
  326.     char error_string[400];
  327.     strcpy(error_string, "\nerror in File ");
  328.     if (nm != 0)
  329.       strcat(error_string, nm);
  330.     (*File_error_handler)(error_string);
  331.   }
  332. }
  333.  
  334. //-------------------------------------------------------------------
  335.  
  336. // All of the following could be inlined if desired.
  337. // However, all are a bit too long for routine inlining.
  338.  
  339. #define COULD_BE_INLINE
  340.  
  341. COULD_BE_INLINE void File::check_state() // ensure fp & state agree about eof
  342. {
  343.   if (fp != 0)
  344.   {
  345.     if (feof(fp))
  346.       state |= _eof;
  347.     else
  348.       state &= ~_eof;
  349.     if (ferror(fp))
  350.       state |= _fail;
  351.   }
  352. }
  353.  
  354. COULD_BE_INLINE File& File::failif(int cond)
  355. { 
  356.   if (cond) error(); else { errno = 0; state = _good; check_state(); }
  357.   return *this; 
  358. }
  359.  
  360. COULD_BE_INLINE File& File::get(char& c)
  361. { 
  362.   if (readable())
  363.   {
  364.     int ch = getc(fp);
  365.     c = ch;
  366.     failif (ch == EOF);
  367.   }
  368.   return *this;
  369. }
  370.  
  371. COULD_BE_INLINE File& File::put(char  c) 
  372. { 
  373.   return failif (!writable() ||  putc(c, fp) == EOF);
  374. }
  375.  
  376. COULD_BE_INLINE File& File::unget(char c)
  377. { 
  378.   return failif(!is_open() || !(rw & 01) || ungetc(c, fp) == EOF);
  379. } 
  380.  
  381. COULD_BE_INLINE File& File::putback(char c)
  382. { 
  383.   return failif (!is_open() || !(rw & 01) || ungetc(c, fp) == EOF);
  384. }
  385.  
  386. COULD_BE_INLINE File& File::read(void* x, int sz, int n)
  387. { 
  388.   return failif (!readable() || (stat = fread(x, sz, n, fp)) != n);
  389. } 
  390.  
  391. COULD_BE_INLINE File& File::write(void* x, int sz, int n) 
  392. { 
  393.   return failif (!writable() || (stat = fwrite(x, sz, n, fp)) != n);
  394. }
  395.  
  396. COULD_BE_INLINE  File& File::put(const char* s)
  397. { 
  398.   return failif(!writable() || fputs(s, fp) == EOF);
  399. }
  400.  
  401. COULD_BE_INLINE File& File::flush()
  402. { 
  403.   return failif(!is_open() || fflush(fp) == EOF);
  404. }
  405.  
  406. COULD_BE_INLINE File& File::seek(long pos, int seek_mode = 0)
  407. { 
  408.   return failif (!is_open() || fseek(fp, pos, seek_mode) < 0); 
  409. }
  410.  
  411. COULD_BE_INLINE long File::tell()
  412. { 
  413.   failif (!is_open() || (stat = ftell(fp) < 0));
  414.   return stat;
  415. }
  416.  
  417. //------------------------------------------------------------------
  418.  
  419. File& File::get(char* s, int n, char terminator = '\n')
  420. {
  421.   if (!readable())
  422.   {
  423.     error();
  424.     return *this;
  425.   }
  426.  
  427.   char ch;
  428.   stat = n;
  429.  
  430.   if (n > 0 && (get(ch)))
  431.   {
  432.     if (ch == terminator)
  433.       unget(ch);
  434.     else
  435.     {
  436.       *s++ = ch; --n;
  437.       while (n > 0 && (get(ch)))
  438.       {
  439.         if (ch == terminator)
  440.         {
  441.           unget(ch);
  442.           break;
  443.         }
  444.         else
  445.         {
  446.           *s++ = ch; --n;
  447.         }
  448.       }
  449.     }
  450.   }
  451.  
  452.   *s = 0;
  453.   return failif((stat != 0) && ((stat -= n) == 0));
  454. }
  455.  
  456. File& File::getline(char* s, int n, char terminator = '\n')
  457. {
  458.   if (!readable())
  459.   {
  460.     error();
  461.     return *this;
  462.   }
  463.  
  464.   char ch;
  465.   stat = n;
  466.  
  467.   while (n > 0 && (get(ch)))
  468.   {
  469.     --n;
  470.     if ((*s++ = ch) == terminator)
  471.       break;
  472.   }
  473.  
  474.   *s = 0;
  475.   return failif((stat != 0) && ((stat -= n) == 0));
  476. }
  477.  
  478.  
  479.