file.c

spiht的压缩解压缩c编写的

#include "spiht.h"
#include "spihtdecode.h"

#define QCCFILE_READ 1
#define QCCFILE_WRITE 2
#define QCCFILE_PIPETRUE 1
#define QCCFILE_PIPEFALSE 2

typedef struct
{
  FILE *fileptr;
  int access_mode;
  int pipe_type;
} QccFileEntry;

static int QccFileTableLen = 0;
static QccFileEntry *QccFileTable;

void QccFileInit(void)
{
  QccFileTableLen = 0;
  QccFileTable = NULL;
}

int QccFileExists(const QccString filename)
{
  struct stat statbuf;

  return(!stat(filename, &statbuf));
}

int QccFileGetExtension(const QccString filename, QccString extension)
{
  char *ptr;
  QccString filename2;

  QccStringCopy(filename2, filename);

  if ((ptr = strrchr(filename2, '.')) == NULL)
    {
      QccStringMakeNull(extension);
      return(1);
    }

  if (!strcmp(ptr + 1, "gz"))
    {
      *ptr = '\0';

      if ((ptr = strrchr(filename2, '.')) == NULL)
        {
          QccStringMakeNull(extension);
          return(1);
        }
    }

  QccStringCopy(extension, ptr + 1);

  return(0);
}

static int QccFileTableAddEntry(FILE *fileptr,
                                const int access_mode,
                                const int pipe_flag)
{
  int return_value = 0;

  if (QccFileTable == NULL)
    {
      if ((QccFileTable = 
           (QccFileEntry *)malloc(sizeof(QccFileEntry))) == NULL)
        {
          QccErrorAddMessage("(QccFileTableAddEntry): Error allocating memory");
          goto Error;
        }
      QccFileTableLen = 1;
    }
  else
    {
      QccFileTableLen++;
      if ((QccFileTable = 
           (QccFileEntry *)realloc((void *)QccFileTable,
                                   sizeof(QccFileEntry)*QccFileTableLen)) ==
          NULL)
        {
          QccErrorAddMessage("(QccFileTableAddEntry): Error reallocating memory");
          goto Error;
        }
    }

  QccFileTable[QccFileTableLen - 1].fileptr = fileptr;
  QccFileTable[QccFileTableLen - 1].access_mode = access_mode;
  QccFileTable[QccFileTableLen - 1].pipe_type = pipe_flag;

  return_value = 0;
  goto Return;

 Error:
  return_value = 1;

 Return:
  return(return_value);
}

static int QccFileGetPipeType(FILE *fileptr)
{
  int file_cnt;
  int return_value = 0;

  for (file_cnt = 0; file_cnt < QccFileTableLen; file_cnt++)
    if (QccFileTable[file_cnt].fileptr == fileptr)
      {
        return_value = QccFileTable[file_cnt].pipe_type;
        break;
      }

  return(return_value);
}

static int QccFileTableRemoveEntry(FILE *fileptr)
{
  int file_cnt, file_cnt2, file_cnt3;
  QccFileEntry *tmp_table;
  int return_value = 0;

  for (file_cnt = 0; file_cnt < QccFileTableLen; file_cnt++)
    if (QccFileTable[file_cnt].fileptr == fileptr)
      break;

  if (file_cnt >= QccFileTableLen)
    {
      QccErrorAddMessage("(QccFileTableRemoveEntry): fileptr is not in table");
      goto Error;
    }

  if (QccFileTableLen == 1)
    {
      free(QccFileTable);
      QccFileTableLen = 0;
      QccFileTable = NULL;
      goto Return;
    }

  if ((tmp_table = 
       (QccFileEntry *)malloc(sizeof(QccFileEntry)*(QccFileTableLen - 1))) == 
      NULL)
    {
      QccErrorAddMessage("(QccFileTableRemoveEntry): Error allocating memory");
      goto Error;
    }

  for (file_cnt2 = 0, file_cnt3 = 0; file_cnt2 < QccFileTableLen;
       file_cnt2++)
    if (file_cnt2 != file_cnt)
      tmp_table[file_cnt3++] = QccFileTable[file_cnt2];

  free(QccFileTable);
  QccFileTable = tmp_table;
  QccFileTableLen--;

  return_value = 0;
  goto Return;

 Error:
  return_value = 1;

 Return:
  return(return_value);
}

static FILE *QccFileOpenRead(const QccString filename, int *pipe_flag)
{
  int len;
  FILE *infile = NULL;

  *pipe_flag = QCCFILE_PIPEFALSE;
  if (!QccFileExists(filename))
    {
      QccErrorAddMessage("(QccFileOpenRead): file %s not found",
                         filename);
      return(NULL);
    }

  if ((infile = fopen(filename, "rb")) == NULL)
    {
      QccErrorAddMessage("(QccFileOpenRead): Unable to open %s for reading",
                         filename);
      return(NULL);
    }
  len = strlen(filename);
  
  return(infile);
}

static FILE *QccFileOpenWrite(const QccString filename, int *pipe_flag)
{
  int len;
  FILE *outfile = NULL;

  len = strlen(filename);

  *pipe_flag = QCCFILE_PIPEFALSE;
  
  if ((outfile = fopen(filename, "wb")) == NULL)
      QccErrorAddMessage("(QccFileOpenWrite): unable to open %s for writing",
                           filename);
  return(outfile);
}

FILE *QccFileOpen(const QccString filename, const QccString mode)
{
  FILE *fileptr = NULL;
  int pipe_flag;
  int access_mode;

  if (mode == NULL)
    {
      QccErrorAddMessage("(QccFileOpen): Error invalid open mode");
      return(NULL);
    }

  if (mode[0] == 'r')
    {
      if ((fileptr = QccFileOpenRead(filename, &pipe_flag)) == NULL)
        {
          QccErrorAddMessage("(QccFileOpen): Error calling QccFileOpenRead()");
          return(NULL);
        }

      access_mode = QCCFILE_READ;
    }
  else
    if (mode[0] == 'w')
      {
        if ((fileptr = QccFileOpenWrite(filename, &pipe_flag)) == NULL)
          {
            QccErrorAddMessage("(QccFileOpen): Error calling QccFileOpenWrite()");
            return(NULL);
          }

        access_mode = QCCFILE_WRITE;
      }
    else
      {
        QccErrorAddMessage("(QccFileOpen): Open mode %s is invalid",
                           mode);
        return(NULL);
      }

  if (QccFileTableAddEntry(fileptr, access_mode, pipe_flag))
    {
      QccErrorAddMessage("(QccFileOpen): Error calling QccFileTableAddEntry()");
      return(NULL);
    }

  return(fileptr);
}

int QccFileClose(FILE *fileptr)
{
  int pipe_flag;

  if (fileptr == NULL)
    return(0);

  if (!(pipe_flag = QccFileGetPipeType(fileptr)))
    {
      QccErrorAddMessage("(QccFileClose): fileptr is not in QccFileTable");
      return(1);
    }

  if (pipe_flag == QCCFILE_PIPEFALSE)
    fclose(fileptr);

  if (QccFileTableRemoveEntry(fileptr))
    {
      QccErrorAddMessage("(QccFileClose): Error calling QccFileTableRemoveEntry()");
      return(1);
    }

  return(0);
}

int QccFileFlush(FILE *fileptr)
{
  if (fflush(fileptr))
    {
      QccErrorAddMessage("(QccFileFlush): Error flushing file");
      return(1);
    }

  return(0);
}

int QccFileReadChar(FILE *infile, char *val)
{
  int read_val;

  if (infile == NULL)
    return(0);

  read_val = fgetc(infile);
  if (val != NULL)
    *val = (char)read_val;

  return(ferror(infile) || feof(infile));
}

int QccFileWriteChar(FILE *outfile, char val)
{
  if (outfile == NULL)
    return(0);

  fputc((int)val, outfile);
  return(ferror(outfile));
}

int QccFileReadDouble(FILE *infile, double *val)
{
  unsigned char ch[QCC_INT_SIZE];
  float tmp;

  if (infile == NULL)
    return(0);

  fread(ch, 1, QCC_INT_SIZE, infile);
  if (ferror(infile) || feof(infile))
    return(1);

  if (val != NULL)
    {
      QccBinaryCharToFloat(ch, &tmp);
      
      if (val != NULL)
        *val = tmp;
    }

  return(0);
}

int QccFileWriteDouble(FILE *outfile, double val)
{
  unsigned char ch[QCC_INT_SIZE];
  float tmp;

  if (outfile == NULL)
    return(0);

  tmp = val;
  QccBinaryFloatToChar(tmp, ch);
  fwrite(ch, 1, QCC_INT_SIZE, outfile);
  return(ferror(outfile));

}

int QccFileReadString(FILE *infile, QccString s)
{
  QccString cmd;

  if (infile == NULL)
    return(0);

  if (s == NULL)
    return(0);

  QccStringSprintf(cmd, "%%%ds", QCCSTRINGLEN);
  fscanf(infile, cmd, s);

  return(ferror(infile) || feof(infile));
}

int QccFileWriteString(FILE *outfile, const QccString s)
{
  if (outfile == NULL)
    return(0);

  if (s == NULL)
    return(0);

  fprintf(outfile, "%s", s);

  return(ferror(outfile));
}

static int QccFileSkipComment(FILE *infile)
{
  unsigned char ch;

  if (infile == NULL)
    return(0);

  do
    {
      ch = fgetc(infile);
      if (ferror(infile))
        return(1);
    }
  while (ch != '\n');

  ungetc(ch, infile);

  return(0);
}

int QccFileSkipWhiteSpace(FILE *infile, int skip_comments_flag)
{
  unsigned char ch;

  if (infile == NULL)
    return(0);

  do
    {
      ch = fgetc(infile);
      if (ferror(infile))
        return(1);

      if (((ch == '#') || (ch == '*') || (ch == '/'))
          && skip_comments_flag)
        {
          if (QccFileSkipComment(infile))
            return(1);
          ch = fgetc(infile);
          if (ferror(infile))
            return(1);
        }
    }
  while ((ch == ' ') || (ch == '\n') || (ch == '\t') || (ch == '\r'));

  ungetc(ch, infile);
  return(0);

}

int QccFileReadMagicNumber(FILE *infile, QccString magic_num,
                           int *major_version_number,
                           int *minor_version_number)
{
  QccString header_value;
  int major, minor;

  if (infile == NULL)
    return(0);

  if (magic_num == NULL)
    return(1);

  if (QccFileReadString(infile, header_value))
    return(1);
  if (QccFileSkipWhiteSpace(infile, 1))
    return(1);

  sscanf(header_value, "%[^0-9]%d.%d", magic_num, &major, &minor);

  if (major_version_number != NULL)
    *major_version_number = major;
  if (minor_version_number != NULL)
    *minor_version_number = minor;

  return(0);
}

int QccFileWriteMagicNumber(FILE *outfile, const QccString magic_num)
{
  QccString header_value;
  int major;
  int minor;

  if (outfile == NULL)
    return(0);

  QccGetQccPackVersion(&major, &minor, NULL);

  QccStringSprintf(header_value, "%s%d.%d\n",
          magic_num, major, minor);

  if (QccFileWriteString(outfile, header_value))
    {
      QccErrorAddMessage("(QccFileWriteMagicNumber): Error writing magic number");
      goto QccErr;
    }

  return(0);

 QccErr:
  return(1);
}

int QccFileGetMagicNumber(const QccString filename, QccString magic_num)
{
  FILE *infile;

  if (filename == NULL)
    return(0);
  if (magic_num == NULL)
    return (0);

  if ((infile = QccFileOpen(filename, "r")) == NULL)
    {
      QccErrorAddMessage("(QccFileGetMagicNumber): Error opening %s for reading",
                         filename);
      return(1);
    }
  
  if (QccFileReadMagicNumber(infile, magic_num,
                             NULL, NULL))
    {
      QccErrorAddMessage("(QccFileGetMagicNumber): Error reading magic number of %s",
                         filename);
      return(1);
    }
  
  QccFileClose(infile);
  
  return(0);
}