libsent/src/util/gzfile.c

Go to the documentation of this file.

/*
 * Copyright (c) 1991-2006 Kawahara Lab., Kyoto University
 * Copyright (c) 2000-2005 Shikano Lab., Nara Institute of Science and Technology
 * Copyright (c) 2005-2006 Julius project team, Nagoya Institute of Technology
 * All rights reserved
 */

#include <sent/stddefs.h>
#include <errno.h>

#ifdef HAVE_ZLIB
/* use built-in zlib functions */
/* current implementatin casts gzFile to FILE... */

#include <zlib.h>

FILE *
fopen_readfile(char *filename)
{
  gzFile gp;
  gp = gzopen(filename, "rb");
  if (gp == NULL) perror("fopen_readfile");
  return(gp);
}

int
fclose_readfile(FILE *fp)
{
  if (gzclose((gzFile)fp) < 0) {
    perror("fclose_readfile");
    return -1;
  }
  return 0;
}

size_t
myfread(void *ptr, size_t size, size_t n, FILE *fp)
{
  int cnt;
  cnt = gzread((gzFile)fp, (voidp)ptr, (unsigned)size * n);
  if (cnt < 0) {
    perror("myfread");
    return(-1);
  }
  return(cnt / size);
}

int
myfgetc(FILE *fp)
{
  int ret;
  ret = gzgetc((gzFile)fp);
  return(ret);
}

int
myfeof(FILE *fp)
{
  if (gzeof((gzFile)fp) == 0) {
    return 0;
  }
  return 1;
}

int
myfrewind(FILE *fp)
{
  if (gzrewind((gzFile)fp) != 0) return -1;
  return 0;
}

#else  /* ~HAVE_ZLIB */

/* use external "gzip" via pipe */
/* can read only one file at a time */

static boolean isopen = FALSE;  
static FILE *zcat_pipe = NULL; 

static boolean
is_zcatfile(char *filename)
{
  int len;

  len = strlen(filename);
  if (strmatch(".Z", &filename[len - 2])) {
    return TRUE;
  } else {
    if (strmatch(".z", &filename[len - 2]) || strmatch(".gz", &filename[len - 3])) {
#ifdef ZCAT
      return TRUE;
#else
      j_error("Error: cannot read \".gz\" or \".z\" file without \"gzip\"\n");
#endif
    } else {
      return FALSE;
    }
  }
}

FILE *
fopen_readfile(char *filename)
{
  FILE *fp;
  char *cmd;

  if (isopen) {         /* already open */
    j_printerr("fopen_readfile: previously opened file is not closed yet.\n");
    return NULL;
  }
  if (is_zcatfile(filename)) {  /* open compressed file */
    cmd = (char *)mymalloc(strlen(ZCAT) + strlen(filename) + 2);
    strcpy(cmd, ZCAT);
    strcat(cmd," ");
    strcat(cmd, filename);
    zcat_pipe = popen(cmd, "r");
    free(cmd);
    if (zcat_pipe == NULL) {
      perror("fopen_readfile");
      return NULL;
    }
    fp = zcat_pipe;
  } else {                      /* open normal file */
    fp = fopen(filename, "rb");
    if (fp == NULL) {           /* error */
      perror("fopen_readfile");
      return NULL;
    }
    zcat_pipe = NULL;
  }
  
  isopen = TRUE;
  return (fp);
}

int
fclose_readfile(FILE *fp)
{
  if (!isopen) {                /* not opened yet */
    return -1;
  }
  
  if (zcat_pipe != NULL) {      /* pipe opened fp */
    if (fp != zcat_pipe) {
      j_printerr("fp is not opened by fopen_readfile()\n");
      return -1;
    }
    if (pclose(zcat_pipe) == -1) {
      perror("fclose_readfile");
      j_printerr("failed to close gzip pipe\n");
      return -1;
    }
    zcat_pipe = NULL;
  } else  {                     /* normal opened fp */
    if (fclose(fp) != 0) {
      perror("fclose_readfile");
      return -1;
    }
  }
  
  isopen = FALSE;
  return 0;
}

size_t
myfread(void *ptr, size_t size, size_t n, FILE *fp)
{
  size_t ret;
  ret = fread(ptr, size, n, fp);
  if (ret == 0) {
    if (myfeof(fp) == 1) {
      return 0;
    } else {
      return -1;
    }
  }
  return(ret);
}

int
myfgetc(FILE *fp)
{
  int ret;
  ret = fgetc(fp);
  if (ret == EOF) return -1;
  return(ret);
}

int
myfeof(FILE *fp)
{
  if (feof(fp) == 0) {
    return 0;
  }
  return 1;
}

int
myfrewind(FILE *fp)
{
  if (fseek(fp, 0L, SEEK_SET) != 0) return -1;
  return 0;
}

#endif /* ~HAVE_ZLIB */

FILE *
fopen_writefile(char *filename)
{
  FILE *fp;

  fp = fopen(filename, "wb");
  if (fp == NULL) {             /* error */
    perror("fopen_writefile");
  }
  return (fp);
}

int                             /* return value: 0=success, -1=failure */
fclose_writefile(FILE *fp)
{
  if (fclose(fp) != 0) {
    return -1;
  }
  return 0;
}

size_t
myfwrite(void *ptr, size_t size, size_t n, FILE *fp)
{
  return(fwrite(ptr, size, n, fp));
}

---