LCOV - code coverage report
Current view: top level - src - mfile.cpp (source / functions) Hit Total Coverage
Test: test_coverage.info Lines: 65 149 43.6 %
Date: 2017-06-21 14:32:49 Functions: 6 15 40.0 %

          Line data    Source code
       1             : //////////////////////////////////////////////////////////////////////
       2             : //
       3             : //  FILE:       mfile.cpp
       4             : //              MFile class methods
       5             : //
       6             : //  Part of:    Scid (Shane's Chess Information Database)
       7             : //  Version:    2.0
       8             : //
       9             : //  Notice:     Copyright (c) 2000  Shane Hudson.  All rights reserved.
      10             : //
      11             : //  Author:     Shane Hudson (sgh@users.sourceforge.net)
      12             : //
      13             : //////////////////////////////////////////////////////////////////////
      14             : 
      15             : #include "common.h"
      16             : #include "mfile.h"
      17             : #include "misc.h"
      18             : 
      19             : // GZ_BUFFER_SIZE: number of bytes read from a Gzip file at a time.
      20             : const uint GZ_BUFFER_SIZE = 1024;
      21             : 
      22             : void
      23          13 : MFile::Init ()
      24             : {
      25          13 :     Handle = NULL;
      26          13 :     GzHandle = NULL;
      27          13 :     GzBuffer = NULL;
      28          13 :     FileMode = FMODE_Both;
      29          13 :     Type = MFILE_MEMORY;
      30          13 :     Capacity = 0;
      31          13 :     Location = 0;
      32          13 :     SeqReadLocation = 0;
      33          13 :     Data = NULL;
      34          13 :     CurrentPtr = NULL;
      35          13 :     FileName = NULL;
      36          13 : }
      37             : 
      38             : void
      39           0 : MFile::Extend ()
      40             : {
      41           0 :     ASSERT (Type == MFILE_MEMORY);
      42             :     // Double Capacity, starting with at least 8 Kb:
      43           0 :     uint oldCapacity = Capacity;
      44           0 :     Capacity += Capacity;
      45           0 :     if (Capacity < 8192) { Capacity = 8192; }
      46           0 :     byte * oldData = Data;
      47           0 :     Data = new byte [Capacity];
      48           0 :     CurrentPtr = &(Data[Location]);
      49           0 :     if (oldData != NULL) {
      50             :         // Copy data to new array:
      51           0 :         for (uint i=0; i < oldCapacity; i++) { Data[i] = oldData[i]; }
      52           0 :         delete[] oldData;
      53             :     }
      54           0 : }
      55             : 
      56             : errorT
      57        2000 : MFile::Seek (uint position)
      58             : {
      59        2000 :     if (Type == MFILE_MEMORY) {
      60           0 :         while (position >= Capacity) { Extend(); }
      61           0 :         CurrentPtr = &(Data[position]);
      62           0 :         Location = position;
      63           0 :         return OK;
      64             :     }
      65             : 
      66        2000 :     if (Type == MFILE_SEQREAD) {
      67           0 :         Type = MFILE_REGULAR;
      68           0 :         if (Data != NULL) delete[] Data;
      69           0 :         Data = CurrentPtr = NULL;
      70           0 :         Capacity = 0;
      71             :     } else {
      72        2000 :         if (FileMode != FMODE_Both  &&  Location == position) { return OK; }
      73             :     }
      74             : 
      75             :     int result;
      76        2000 :     if (Type == MFILE_GZIP) {
      77           0 :         result = gzseek (GzHandle, position, 0);
      78           0 :         GzBuffer_Avail = 0;
      79             :     } else {
      80        2000 :         result = fseek (Handle, position, 0);
      81             :     }
      82        2000 :     if (result != 0) { return ERROR_FileSeek; }
      83        2000 :     Location = position;
      84        2000 :     return OK;
      85             : }
      86             : 
      87             : errorT
      88           4 : MFile::Flush ()
      89             : {
      90           4 :     if (Type != MFILE_REGULAR  ||  FileMode == FMODE_ReadOnly) { return OK; }
      91           4 :     return (fflush (Handle) == 0 ? OK : ERROR_FileWrite);
      92             : }
      93             : 
      94             : errorT
      95           7 : MFile::Open (const char * name, fileModeT fmode)
      96             : {
      97           7 :     ASSERT (Handle == NULL  &&  GzHandle == NULL);
      98           7 :     const char * modeStr = NULL;
      99           7 :     switch (fmode) {
     100             :         case FMODE_ReadOnly:   modeStr = "rb";  break;
     101           1 :         case FMODE_WriteOnly:  modeStr = "wb";  break;
     102           1 :         case FMODE_Both:       modeStr = "r+b"; break;
     103             :         default:               return ERROR_FileMode;
     104             :     }
     105             : 
     106           6 :     const char * suffix = strFileSuffix (name);
     107           6 :     if (suffix != NULL  &&  strEqual (suffix, GZIP_SUFFIX)) {
     108             :         // We can only open GZip files read-only for now:
     109           0 :         if (fmode != FMODE_ReadOnly) {
     110             :             return ERROR_FileOpen;
     111             :         }
     112           0 :         GzHandle = gzopen (name, "rb");
     113             :         if (GzHandle == NULL) { return ERROR_FileOpen; }
     114             :         Type = MFILE_GZIP;
     115             :         GzBuffer = new byte [GZ_BUFFER_SIZE];
     116             :         GzBuffer_Current = GzBuffer;
     117             :         GzBuffer_Avail = 0;
     118             :     } else {
     119           6 :         Handle = fopen (name, modeStr);
     120           6 :         if (Handle == NULL) { return ERROR_FileOpen; }
     121           6 :         Type = MFILE_SEQREAD;
     122           6 :         Data = new byte [SEQREADBUFSIZE];
     123           6 :         CurrentPtr = Data;
     124           6 :         SeqReadLocation = 0;
     125           6 :         fseek(Handle, 0L, SEEK_END);
     126           6 :         Capacity = ftell(Handle);
     127           6 :         fseek(Handle, 0L, SEEK_SET);
     128             :     }
     129             : 
     130           6 :     FileMode = fmode;
     131           6 :     FileName = strDuplicate (name);
     132           6 :     Location = 0;
     133           6 :     return OK;
     134             : }
     135             : 
     136             : errorT
     137           5 : MFile::Create (const char * name, fileModeT fmode)
     138             : {
     139           5 :     ASSERT (Handle == NULL  &&  GzHandle == NULL);
     140           5 :     const char * modeStr = NULL;
     141           5 :     switch (fmode) {
     142             :         case FMODE_WriteOnly: modeStr = "wb";  break;
     143           5 :         case FMODE_Both:      modeStr = "w+b"; break;
     144             :         default:              return ERROR_FileMode;
     145             :     }
     146           5 :     if ((Handle = fopen (name, modeStr)) == NULL) { return ERROR_FileOpen; }
     147           5 :     FileMode = fmode;
     148           5 :     FileName = strDuplicate (name);
     149           5 :     Location = 0;
     150           5 :     Type = MFILE_REGULAR;
     151           5 :     return OK;
     152             : }
     153             : 
     154             : errorT
     155        2000 : MFile::WriteNBytes (const char * str, uint length)
     156             : {
     157        2000 :     ASSERT (FileMode != FMODE_ReadOnly);
     158             : 
     159        2000 :     errorT err = OK;
     160             : //     while (length-- > 0) {
     161             : //         err = WriteOneByte (*str);
     162             : //         str++;
     163             : //     }
     164             : //     return err;
     165             :     
     166        2000 :     if (Type == MFILE_MEMORY) {
     167           0 :       while (length-- > 0) {
     168           0 :         if (Location >= Capacity) { Extend(); }
     169           0 :         *CurrentPtr++ = *str;
     170           0 :         Location++;
     171           0 :         str++;
     172             :       }
     173             :       return OK;
     174             :     }
     175        2000 :     if (Type == MFILE_SEQREAD) Seek(Location);
     176        2000 :     Location += length;
     177             :     
     178        2000 :     if (Type == MFILE_GZIP) {
     179             :       err = OK;
     180           0 :       while (length-- > 0 && err == OK) {
     181           0 :         err = (gzputc(GzHandle, *str) == EOF) ? ERROR_FileWrite : OK;
     182           0 :         str++;
     183             :       }
     184             :       return err;
     185             :     }
     186        2000 :     return (fwrite( str, length, 1, Handle) != 1) ? ERROR_FileWrite : OK;
     187             : }
     188             : 
     189             : errorT
     190           0 : MFile::ReadNBytes (char * str, uint length)
     191             : {
     192           0 :     ASSERT (FileMode != FMODE_WriteOnly);
     193           0 :     if (Type != MFILE_REGULAR) {
     194           0 :         while (length-- > 0) {
     195           0 :             *str++ = ReadOneByte ();
     196             :         }
     197             :     } else {
     198           0 :         Location += fread (str, 1, length, Handle);
     199             :     }
     200           0 :     return OK;
     201             : }
     202             : 
     203             : errorT
     204           0 : MFile::WriteTwoBytes (uint value)
     205             : {
     206           0 :     ASSERT (FileMode != FMODE_ReadOnly);
     207           0 :     WriteOneByte ((value >> 8) & 255);
     208           0 :     return WriteOneByte (value & 255);
     209             : }
     210             : 
     211             : uint
     212           0 : MFile::ReadTwoBytes ()
     213             : {
     214           0 :     uint result = 0;
     215           0 :     ASSERT (FileMode != FMODE_WriteOnly);
     216           0 :     result = ReadOneByte();
     217           0 :     result <<= 8;
     218           0 :     result += ReadOneByte();
     219           0 :     return result;
     220             : }
     221             : 
     222             : errorT
     223           0 : MFile::WriteThreeBytes (uint value)
     224             : {
     225           0 :     ASSERT (FileMode != FMODE_ReadOnly);
     226           0 :     WriteOneByte ((value >> 16) & 255);
     227           0 :     WriteOneByte ((value >> 8) & 255);
     228           0 :     return WriteOneByte (value & 255);
     229             : }
     230             : 
     231             : uint
     232           0 : MFile::ReadThreeBytes ()
     233             : {
     234           0 :     uint result = 0;
     235           0 :     ASSERT (FileMode != FMODE_WriteOnly);
     236           0 :     result = ReadOneByte();
     237           0 :     result <<= 8;
     238           0 :     result += ReadOneByte();
     239           0 :     result <<= 8;
     240           0 :     result += ReadOneByte();
     241           0 :     return result;
     242             : }
     243             : 
     244             : errorT
     245           0 : MFile::WriteFourBytes (uint value)
     246             : {
     247           0 :     ASSERT (FileMode != FMODE_ReadOnly);
     248           0 :     WriteOneByte ((value >> 24) & 255);
     249           0 :     WriteOneByte ((value >> 16) & 255);
     250           0 :     WriteOneByte ((value >> 8) & 255);
     251           0 :     return WriteOneByte (value & 255);
     252             : }
     253             : 
     254             : 
     255             : uint
     256           0 : MFile::ReadFourBytes ()
     257             : {
     258           0 :     uint result = 0;
     259           0 :     ASSERT (FileMode != FMODE_WriteOnly);
     260           0 :     result = ReadOneByte();
     261           0 :     result <<= 8;
     262           0 :     result += ReadOneByte();
     263           0 :     result <<= 8;
     264           0 :     result += ReadOneByte();
     265           0 :     result <<= 8;
     266           0 :     result += ReadOneByte();
     267           0 :     return result;
     268             : }
     269             : 
     270             : int
     271           0 : MFile::FillGzBuffer ()
     272             : {
     273           0 :     ASSERT (Type == MFILE_GZIP  &&  GzBuffer != NULL  &&  GzBuffer_Avail <= 0);
     274           0 :     int bytesread = gzread (GzHandle, GzBuffer, GZ_BUFFER_SIZE);
     275             :     if (bytesread <= 0) { return EOF; }
     276             :     GzBuffer_Avail = bytesread - 1;
     277             :     GzBuffer_Current = &(GzBuffer[1]);
     278             :     return GzBuffer[0];
     279             :     
     280             : }
     281             : 
     282             : //////////////////////////////////////////////////////////////////////
     283             : //  End of file: mfile.cpp
     284             : //////////////////////////////////////////////////////////////////////

Generated by: LCOV version 1.12