home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / yacl-012.zip / io / binfile.cxx next >
C/C++ Source or Header  |  1995-04-04  |  8KB  |  382 lines
  1.  
  2.  
  3. /*
  4.  *
  5.  *          Copyright (C) 1994, M. A. Sridhar
  6.  *  
  7.  *
  8.  *     This software is Copyright M. A. Sridhar, 1994. You are free
  9.  *     to copy, modify or distribute this software  as you see fit,
  10.  *     and to use  it  for  any  purpose, provided   this copyright
  11.  *     notice and the following   disclaimer are included  with all
  12.  *     copies.
  13.  *
  14.  *                        DISCLAIMER
  15.  *
  16.  *     The author makes no warranties, either expressed or implied,
  17.  *     with respect  to  this  software, its  quality, performance,
  18.  *     merchantability, or fitness for any particular purpose. This
  19.  *     software is distributed  AS IS.  The  user of this  software
  20.  *     assumes all risks  as to its quality  and performance. In no
  21.  *     event shall the author be liable for any direct, indirect or
  22.  *     consequential damages, even if the  author has been  advised
  23.  *     as to the possibility of such damages.
  24.  *
  25.  */
  26.  
  27.  
  28.  
  29. #if defined(__GNUC__)
  30. #pragma implementation
  31. #endif
  32.  
  33.  
  34.  
  35. #if defined(__BORLANDC__)
  36. #include <io.h>
  37. #pragma warn -ncf
  38. #endif
  39.  
  40. #if defined(__GNUC__)
  41. extern "C" {
  42. #include <unistd.h>
  43. #endif
  44. #include <fcntl.h>
  45. #if defined(__OS2__)  // The EMX version of GCC
  46. #include <sys/types.h>
  47. #include <io.h>
  48. #endif
  49. #include <sys/stat.h>
  50. #include <string.h>
  51. #include <errno.h>
  52. #include <stdio.h>
  53. #include <stdlib.h>
  54. #include <stdarg.h>
  55. #ifdef __GNUC__
  56. }
  57. #endif
  58.  
  59. #if defined(__DEC_ULTRIX__)
  60. extern "C" int ftruncate (int, int);
  61. #endif
  62.  
  63. // #ifdef WINDOWS
  64. // #include <windows.h>
  65. // #endif
  66.  
  67. #include "io/binfile.h"
  68. #include "base/error.h"
  69.  
  70.  
  71. #define MAX_LINE_LENGTH 512
  72.  
  73.  
  74.  
  75.  
  76.  
  77. CL_BinaryFile::CL_BinaryFile (const char *pathname, bool createFlag)
  78.     : _pathName (pathname)
  79. {
  80.     struct stat st_buf;
  81.  
  82.     _fd = -1;
  83.     if (createFlag && !Create(_pathName)) {
  84.         _MakeErrorString ("File: create call failed");
  85.         return;
  86.     }
  87.     else if (! Exists (_pathName)) {
  88.         _MakeErrorString ("File: file does not exist");
  89.         return;
  90.     }
  91.  
  92.     if (stat (_pathName, &st_buf) < 0)  {
  93.         _MakeErrorString ("File: stat failed");
  94.         return;
  95.     }
  96.     // #ifndef MS_WINDOWS
  97.     _Open ();
  98.     // #endif
  99. } 
  100.  
  101.  
  102. CL_BinaryFile::~CL_BinaryFile()
  103. {
  104.     _Close();
  105. }
  106.  
  107.  
  108.  
  109. bool CL_BinaryFile::Create (const char* pathName)
  110. {
  111.     int fd;
  112.  
  113.     // #ifndef MS_WINDOWS
  114.     if ((fd = creat (pathName, S_IREAD|S_IWRITE)) <= 0) {
  115.         return FALSE;
  116.     }
  117.     close (fd);
  118. // #else
  119. //     OFSTRUCT    OfStruct;
  120. //  
  121. //     int mode =   OF_READWRITE | OF_CREATE;   //This will truncate the file
  122. //     fd = OpenFile (_pathName, &OfStruct, mode);
  123. //     _lclose (fd);
  124. // #endif
  125.     return TRUE;
  126. }
  127.  
  128.  
  129. long CL_BinaryFile::Size () const
  130. {
  131. // #ifdef __BORLANDC__
  132.     long current = lseek (_fd, 0L, SEEK_CUR);
  133.     if (current == -1)
  134.         return -1;
  135.     long size = lseek  (_fd, 0L, SEEK_END);
  136.     if (size == -1)
  137.         return -1;
  138.     lseek (_fd, current, SEEK_SET);
  139.     return size;
  140. // #else
  141. //     struct stat st_buf;
  142. //     _MakeErrorString ("");
  143. //     if (stat (_pathName, &st_buf) < 0)  {
  144. //         _MakeErrorString ("Size: stat failed");
  145. //         return -1;
  146. //     }
  147. //     unsigned long fileSize =  st_buf.st_size;
  148. //     return fileSize;
  149. // #endif
  150. }
  151.  
  152.  
  153. #if defined(__UNIX__)
  154. #define CHANGESIZE ftruncate
  155. #elif defined(__DOS__) || defined(__OS2__) || defined(__MS_WINDOWS__)
  156. #define CHANGESIZE chsize
  157. #endif
  158.  
  159. bool CL_BinaryFile::ChangeSize (long size)
  160. {
  161.     if (!PrepareToChange())
  162.         return FALSE;
  163. // #ifdef MS_WINDOWS
  164. //     Open ();
  165. // #endif
  166.     _MakeErrorString ("");
  167.     
  168.     if (CHANGESIZE (_fd, size) == -1) {
  169.         _MakeErrorString ("ChangeSize: chsize call failed");
  170.         return FALSE;
  171.     }
  172. // #ifdef MS_WINDOWS
  173. //     Close();
  174. // #endif
  175.     Notify ();
  176.     return TRUE;
  177. }
  178.  
  179.  
  180.  
  181. long CL_BinaryFile::Read (uchar *buffer, long num_bytes)  const
  182. {
  183.     int    nn;
  184.  
  185.     _MakeErrorString ("");
  186. // #ifdef MS_WINDOWS
  187. //     Open();
  188. // #endif
  189.     
  190.     // #ifndef MS_WINDOWS
  191.     if ((nn = read (_fd, buffer, num_bytes)) < 0) {
  192. // #else
  193. //     if ((nn = _lread (fd, buffer, num_bytes)) < 0) {
  194. // #endif
  195.         _MakeErrorString ("Read: read call failed");
  196.     }
  197. // #ifdef MS_WINDOWS
  198. //     Close();
  199. // #endif
  200.     return nn;
  201. }
  202.  
  203.  
  204.  
  205.     
  206.  
  207. bool CL_BinaryFile::Write (uchar *buffer, long num_bytes)
  208. {
  209.  
  210. // #ifdef MS_WINDOWS
  211. //     Open();
  212. // #endif
  213.  
  214.     if (!PrepareToChange())
  215.         return FALSE;
  216.     _MakeErrorString ("");
  217.     // #ifndef MS_WINDOWS
  218.     if ((write (_fd, buffer, num_bytes)) < 0) {
  219.         _MakeErrorString ("Write: write call failed");
  220.         return FALSE;
  221.     }
  222. // #else
  223. //     if ((_lwrite (fd, buffer, num_bytes)) < 0) {
  224. //         CL_Error::Fatal ("CL_BinaryFile::Write: write failed: %s",
  225. //             strerror (errno));
  226. //     }
  227. // #endif
  228. // #ifdef MS_WINDOWS
  229. //     Close();
  230. // #endif
  231.     Notify ();
  232.     return TRUE;
  233.  
  234. }
  235.  
  236.  
  237.  
  238.  
  239. bool CL_BinaryFile::SeekTo (long position) const
  240. {
  241.     _MakeErrorString ("");
  242. // #ifdef MS_WINDOWS
  243. //     if ((retval = _llseek (fd, position, SEEK_SET)) < 0) {
  244. // #else
  245.     if (lseek (_fd, position, SEEK_SET) == -1L) {
  246.         // #endif
  247.         _MakeErrorString ("SeekTo: lseek call failed");
  248.         return FALSE;
  249.     }
  250.     return TRUE;
  251. }
  252.  
  253.  
  254. bool CL_BinaryFile::SeekRelative (long position) const
  255. {
  256.     _MakeErrorString ("");
  257. // #ifdef MS_WINDOWS
  258. //     if ((retval = _llseek (fd, position, SEEK_CUR)) < 0) {
  259. // #else
  260.     if (lseek (_fd, position, SEEK_CUR) == -1L) {
  261. // #endif
  262.         _MakeErrorString ("SeekRelative: lseek call failed");
  263.         return FALSE;
  264.     }
  265.     return TRUE;
  266. }
  267.  
  268.  
  269. bool CL_BinaryFile::Eof () const
  270. {
  271. #if defined(__UNIX__)
  272.     long current = lseek (_fd, 0L, SEEK_CUR);
  273.     if (current == -1)
  274.         return -1;
  275.     long size = lseek  (_fd, 0L, SEEK_END);
  276.     if (size == -1)
  277.         return -1;
  278.     lseek (_fd, current, SEEK_SET);
  279.     return size == current;
  280. #elif defined(__DOS__) || defined(__OS2__) || defined(__MS_WINDOWS__)
  281.     return eof (_fd);
  282. #endif
  283. }
  284.  
  285.  
  286. long CL_BinaryFile::Offset () const
  287. {
  288.     return lseek (_fd, 0, SEEK_CUR);
  289. }
  290.  
  291.  
  292. bool CL_BinaryFile::Exists (const char *pathname)
  293. {
  294.     return (access (pathname, 0) == 0);
  295. }  
  296.  
  297.  
  298.  
  299.  
  300. // Protected methods
  301.  
  302. bool CL_BinaryFile::_Open()
  303. {
  304.     _MakeErrorString ("");
  305.     // #ifndef MS_WINDOWS
  306.     int mode = O_RDWR;
  307.     
  308. #if defined(__DOS__) || defined(__MS_WINDOWS__) || defined(__OS2__)
  309.     mode |= O_BINARY;
  310. #endif
  311.     _fd = open (_pathName.AsPtr(), mode, S_IREAD | S_IWRITE);
  312. // #else
  313. //     OFSTRUCT    OfStruct;
  314. // 
  315. //     int mode =   OF_READWRITE;
  316. //     fd = OpenFile (_pathName.AsPtr(), &OfStruct, mode);
  317. // #endif
  318.     if (_fd < 0) 
  319.         _MakeErrorString ("_Open: open call failed");
  320.     return (_fd >= 0);
  321. }  // End of function Open
  322.  
  323.  
  324. void CL_BinaryFile::_Close()
  325. {
  326.  
  327.     if (_fd < 0)
  328.         return;
  329. // #ifndef MS_WINDOWS
  330.     close (_fd);
  331. // #else
  332. //     _lclose (fd);
  333. // #endif
  334.     _fd = -1;
  335. }  // End of function Close
  336.  
  337.  
  338.  
  339.  
  340. bool CL_BinaryFile::SeekToEnd () const
  341. {
  342.     long retval;
  343.  
  344.     _MakeErrorString ("");
  345. // #ifdef MS_WINDOWS
  346. //     if ((retval = _llseek (fd, 0L, SEEK_END)) < 0) {
  347. // #else
  348.     if ((retval = lseek (_fd, 0L, SEEK_END)) < 0) {
  349.         // #endif
  350.         _MakeErrorString  ("SeekToEnd: seek call failed");
  351.     }
  352.     return retval >= 0;
  353. }
  354.  
  355.  
  356.  
  357. CL_String CL_BinaryFile::ErrorString() const
  358. {
  359.     return _errorString;
  360. }
  361.  
  362.  
  363.  
  364.  
  365. void CL_BinaryFile::_MakeErrorString (const char* msg) const
  366. {
  367.     if (CL_String (msg).Length() > 0) {
  368.         ((CL_BinaryFile*) this)->_errorString.AssignWithFormat
  369.             ("File %s: %s: %s", _pathName.AsPtr(), msg, strerror (errno));
  370.         // Cast away const
  371.         CL_Error::Warning (_errorString);
  372.     }
  373.     else
  374.         ((CL_BinaryFile*) this)->_errorString = "";
  375.         
  376. }
  377.  
  378.  
  379. #ifdef __BORLANDC__
  380. #pragma warn .ncf
  381. #endif
  382.