source: glpk-cmake/src/glpenv07.c

/* glpenv07.c (stream input/output) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*
*  Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,
*  2009, 2010 Andrew Makhorin, Department for Applied Informatics,
*  Moscow Aviation Institute, Moscow, Russia. All rights reserved.
*  E-mail: <mao@gnu.org>.
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see <http://www.gnu.org/licenses/>.
***********************************************************************/

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include "glpenv.h"

/***********************************************************************
*  NAME
*
*  lib_err_msg - save error message string
*
*  SYNOPSIS
*
*  #include "glpenv.h"
*  void lib_err_msg(const char *msg);
*
*  DESCRIPTION
*
*  The routine lib_err_msg saves an error message string specified by
*  the parameter msg. The message is obtained by some library routines
*  with a call to strerror(errno). */

void lib_err_msg(const char *msg)
{     ENV *env = get_env_ptr();
      int len = strlen(msg);
      if (len >= IOERR_MSG_SIZE)
         len = IOERR_MSG_SIZE - 1;
      memcpy(env->ioerr_msg, msg, len);
      if (len > 0 && env->ioerr_msg[len-1] == '\n') len--;
      env->ioerr_msg[len] = '\0';
      return;
}

/***********************************************************************
*  NAME
*
*  xerrmsg - retrieve error message string
*
*  SYNOPSIS
*
*  #include "glpenv.h"
*  const char *xerrmsg(void);
*
*  RETURNS
*
*  The routine xerrmsg returns a pointer to an error message string
*  previously set by some library routine to indicate an error. */

const char *xerrmsg(void)
{     ENV *env = get_env_ptr();
      return env->ioerr_msg;
}

/***********************************************************************
*  NAME
*
*  xfopen - open a stream
*
*  SYNOPSIS
*
*  #include "glpenv.h"
*  XFILE *xfopen(const char *fname, const char *mode);
*
*  DESCRIPTION
*
*  The routine xfopen opens the file whose name is a string pointed to
*  by fname and associates a stream with it.
*
*  The parameter mode points to a string, which indicates the open mode
*  and should be one of the following:
*
*  "r"   open text file for reading;
*  "w"   truncate to zero length or create text file for writing;
*  "rb"  open binary file for reading;
*  "wb"  truncate to zero length or create binary file for writing.
*
*  RETURNS
*
*  The routine xfopen returns a pointer to the object controlling the
*  stream. If the open operation fails, xfopen returns NULL. */

static void *c_fopen(const char *fname, const char *mode);
static void *z_fopen(const char *fname, const char *mode);

static int is_gz_file(const char *fname)
{     char *ext = strrchr(fname, '.');
      return ext != NULL && strcmp(ext, ".gz") == 0;
}

XFILE *xfopen(const char *fname, const char *mode)
{     ENV *env = get_env_ptr();
      XFILE *fp;
      int type;
      void *fh;
      if (!is_gz_file(fname))
      {  type = FH_FILE;
         fh = c_fopen(fname, mode);
      }
      else
      {  type = FH_ZLIB;
         fh = z_fopen(fname, mode);
      }
      if (fh == NULL)
      {  fp = NULL;
         goto done;
      }
      fp = xmalloc(sizeof(XFILE));
      fp->type = type;
      fp->fh = fh;
      fp->prev = NULL;
      fp->next = env->file_ptr;
      if (fp->next != NULL) fp->next->prev = fp;
      env->file_ptr = fp;
done: return fp;
}

/***********************************************************************
*  NAME
*
*  xfgetc - read character from the stream
*
*  SYNOPSIS
*
*  #include "glpenv.h"
*  int xfgetc(XFILE *fp);
*
*  DESCRIPTION
*
*  If the end-of-file indicator for the input stream pointed to by fp
*  is not set and a next character is present, the routine xfgetc
*  obtains that character as an unsigned char converted to an int and
*  advances the associated file position indicator for the stream (if
*  defined).
*
*  RETURNS
*
*  If the end-of-file indicator for the stream is set, or if the
*  stream is at end-of-file, the end-of-file indicator for the stream
*  is set and the routine xfgetc returns XEOF. Otherwise, the routine
*  xfgetc returns the next character from the input stream pointed to
*  by fp. If a read error occurs, the error indicator for the stream is
*  set and the xfgetc routine returns XEOF.
*
*  Note: An end-of-file and a read error can be distinguished by use of
*  the routines xfeof and xferror. */

static int c_fgetc(void *fh);
static int z_fgetc(void *fh);

int xfgetc(XFILE *fp)
{     int c;
      switch (fp->type)
      {  case FH_FILE:
            c = c_fgetc(fp->fh);
            break;
         case FH_ZLIB:
            c = z_fgetc(fp->fh);
            break;
         default:
            xassert(fp != fp);
      }
      return c;
}

/***********************************************************************
*  NAME
*
*  xfputc - write character to the stream
*
*  SYNOPSIS
*
*  #include "glpenv.h"
*  int xfputc(int c, XFILE *fp);
*
*  DESCRIPTION
*
*  The routine xfputc writes the character specified by c (converted
*  to an unsigned char) to the output stream pointed to by fp, at the
*  position indicated by the associated file position indicator (if
*  defined), and advances the indicator appropriately.
*
*  RETURNS
*
*  The routine xfputc returns the character written. If a write error
*  occurs, the error indicator for the stream is set and xfputc returns
*  XEOF. */

static int c_fputc(int c, void *fh);
static int z_fputc(int c, void *fh);

int xfputc(int c, XFILE *fp)
{     switch (fp->type)
      {  case FH_FILE:
            c = c_fputc(c, fp->fh);
            break;
         case FH_ZLIB:
            c = z_fputc(c, fp->fh);
            break;
         default:
            xassert(fp != fp);
      }
      return c;
}

/***********************************************************************
*  NAME
*
*  xferror - test error indicator for the stream
*
*  SYNOPSIS
*
*  #include "glpenv.h"
*  int xferror(XFILE *fp);
*
*  DESCRIPTION
*
*  The routine xferror tests the error indicator for the stream
*  pointed to by fp.
*
*  RETURNS
*
*  The routine xferror returns non-zero if and only if the error
*  indicator is set for the stream. */

static int c_ferror(void *fh);
static int z_ferror(void *fh);

int xferror(XFILE *fp)
{     int ret;
      switch (fp->type)
      {  case FH_FILE:
            ret = c_ferror(fp->fh);
            break;
         case FH_ZLIB:
            ret = z_ferror(fp->fh);
            break;
         default:
            xassert(fp != fp);
      }
      return ret;
}

/***********************************************************************
*  NAME
*
*  xfeof - test end-of-file indicator for the stream
*
*  SYNOPSIS
*
*  #include "glpenv.h"
*  int xfeof(XFILE *fp);
*
*  DESCRIPTION
*
*  The routine xfeof tests the end-of-file indicator for the stream
*  pointed to by fp.
*
*  RETURNS
*
*  The routine xfeof returns non-zero if and only if the end-of-file
*  indicator is set for the stream. */

static int c_feof(void *fh);
static int z_feof(void *fh);

int xfeof(XFILE *fp)
{     int ret;
      switch (fp->type)
      {  case FH_FILE:
            ret = c_feof(fp->fh);
            break;
         case FH_ZLIB:
            ret = z_feof(fp->fh);
            break;
         default:
            xassert(fp != fp);
      }
      return ret;
}

int xfprintf(XFILE *file, const char *fmt, ...)
{     ENV *env = get_env_ptr();
      int cnt, j;
      va_list arg;
      va_start(arg, fmt);
      cnt = vsprintf(env->term_buf, fmt, arg);
      va_end(arg);
      for (j = 0; j < cnt; j++)
      {  if (xfputc(env->term_buf[j], file) < 0)
         {  cnt = -1;
            break;
         }
      }
      return cnt;
}

/***********************************************************************
*  NAME
*
*  xfflush - flush the stream
*
*  SYNOPSIS
*
*  #include "glpenv.h"
*  int xfflush(XFILE *fp);
*
*  DESCRIPTION
*
*  The routine xfflush causes any unwritten data for the output stream
*  pointed to by fp to be written to the associated file.
*
*  RETURNS
*
*  The routine xfflush returns zero if the stream was successfully
*  flushed. Otherwise, xfflush sets the error indicator for the stream
*  and returns XEOF. */

static int c_fflush(void *fh);
static int z_fflush(void *fh);

int xfflush(XFILE *fp)
{     int ret;
      switch (fp->type)
      {  case FH_FILE:
            ret = c_fflush(fp->fh);
            break;
         case FH_ZLIB:
            ret = z_fflush(fp->fh);
            break;
         default:
            xassert(fp != fp);
      }
      return ret;
}

/***********************************************************************
*  NAME
*
*  xfclose - close the stream
*
*  SYNOPSIS
*
*  #include "glpenv.h"
*  int xfclose(XFILE *fp);
*
*  DESCRIPTION
*
*  A successful call to the routine xfclose causes the stream pointed
*  to by fp to be flushed and the associated file to be closed. Whether
*  or not the call succeeds, the stream is disassociated from the file.
*
*  RETURNS
*
*  The routine xfclose returns zero if the stream was successfully
*  closed, or XEOF if any errors were detected. */

static int c_fclose(void *fh);
static int z_fclose(void *fh);

int xfclose(XFILE *fp)
{     ENV *env = get_env_ptr();
      int ret;
      switch (fp->type)
      {  case FH_FILE:
            ret = c_fclose(fp->fh);
            break;
         case FH_ZLIB:
            ret = z_fclose(fp->fh);
            break;
         default:
            xassert(fp != fp);
      }
      fp->type = 0xF00BAD;
      if (fp->prev == NULL)
         env->file_ptr = fp->next;
      else
         fp->prev->next = fp->next;
      if (fp->next == NULL)
         ;
      else
         fp->next->prev = fp->prev;
      xfree(fp);
      return ret;
}

/***********************************************************************
*  The following routines implement stream input/output based on the
*  standard C streams. */

static void *c_fopen(const char *fname, const char *mode)
{     FILE *fh;
      if (strcmp(fname, "/dev/stdin") == 0)
         fh = stdin;
      else if (strcmp(fname, "/dev/stdout") == 0)
         fh = stdout;
      else if (strcmp(fname, "/dev/stderr") == 0)
         fh = stderr;
      else
         fh = fopen(fname, mode);
      if (fh == NULL)
         lib_err_msg(strerror(errno));
      return fh;
}

static int c_fgetc(void *_fh)
{     FILE *fh = _fh;
      int c;
      if (ferror(fh) || feof(fh))
      {  c = XEOF;
         goto done;
      }
      c = fgetc(fh);
      if (ferror(fh))
      {  lib_err_msg(strerror(errno));
         c = XEOF;
      }
      else if (feof(fh))
         c = XEOF;
      else
         xassert(0x00 <= c && c <= 0xFF);
done: return c;
}

static int c_fputc(int c, void *_fh)
{     FILE *fh = _fh;
      if (ferror(fh))
      {  c = XEOF;
         goto done;
      }
      c = (unsigned char)c;
      fputc(c, fh);
      if (ferror(fh))
      {  lib_err_msg(strerror(errno));
         c = XEOF;
      }
done: return c;
}

static int c_ferror(void *_fh)
{     FILE *fh = _fh;
      return ferror(fh);
}

static int c_feof(void *_fh)
{     FILE *fh = _fh;
      return feof(fh);
}

static int c_fflush(void *_fh)
{     FILE *fh = _fh;
      int ret;
      ret = fflush(fh);
      if (ret != 0)
      {  lib_err_msg(strerror(errno));
         ret = XEOF;
      }
      return ret;
}

static int c_fclose(void *_fh)
{     FILE *fh = _fh;
      int ret;
      if (fh == stdin)
         ret = 0;
      else if (fh == stdout || fh == stderr)
         fflush(fh), ret = 0;
      else
         ret = fclose(fh);
      if (ret != 0)
      {  lib_err_msg(strerror(errno));
         ret = XEOF;
      }
      return ret;
}

/***********************************************************************
*  The following routines implement stream input/output based on the
*  zlib library, which provides processing .gz files "on the fly". */

#ifndef HAVE_ZLIB

static void *z_fopen(const char *fname, const char *mode)
{     xassert(fname == fname);
      xassert(mode == mode);
      lib_err_msg("Compressed files not supported");
      return NULL;
}

static int z_fgetc(void *fh)
{     xassert(fh != fh);
      return 0;
}

static int z_fputc(int c, void *fh)
{     xassert(c != c);
      xassert(fh != fh);
      return 0;
}

static int z_ferror(void *fh)
{     xassert(fh != fh);
      return 0;
}

static int z_feof(void *fh)
{     xassert(fh != fh);
      return 0;
}

static int z_fflush(void *fh)
{     xassert(fh != fh);
      return 0;
}

static int z_fclose(void *fh)
{     xassert(fh != fh);
      return 0;
}

#else

#include <zlib.h>

struct z_file
{     /* .gz file handle */
      gzFile file;
      /* pointer to .gz stream */
      int err;
      /* i/o error indicator */
      int eof;
      /* end-of-file indicator */
};

static void *z_fopen(const char *fname, const char *mode)
{     struct z_file *fh;
      gzFile file;
      if (strcmp(mode, "r") == 0 || strcmp(mode, "rb") == 0)
         mode = "rb";
      else if (strcmp(mode, "w") == 0 || strcmp(mode, "wb") == 0)
         mode = "wb";
      else
      {  lib_err_msg("Invalid open mode");
         fh = NULL;
         goto done;
      }
      file = gzopen(fname, mode);
      if (file == NULL)
      {  lib_err_msg(strerror(errno));
         fh = NULL;
         goto done;
      }
      fh = xmalloc(sizeof(struct z_file));
      fh->file = file;
      fh->err = fh->eof = 0;
done: return fh;
}

static int z_fgetc(void *_fh)
{     struct z_file *fh = _fh;
      int c;
      if (fh->err || fh->eof)
      {  c = XEOF;
         goto done;
      }
      c = gzgetc(fh->file);
      if (c < 0)
      {  int errnum;
         const char *msg;
         msg = gzerror(fh->file, &errnum);
         if (errnum == Z_STREAM_END)
            fh->eof = 1;
         else if (errnum == Z_ERRNO)
         {  fh->err = 1;
            lib_err_msg(strerror(errno));
         }
         else
         {  fh->err = 1;
            lib_err_msg(msg);
         }
         c = XEOF;
      }
      else
         xassert(0x00 <= c && c <= 0xFF);
done: return c;
}

static int z_fputc(int c, void *_fh)
{     struct z_file *fh = _fh;
      if (fh->err)
      {  c = XEOF;
         goto done;
      }
      c = (unsigned char)c;
      if (gzputc(fh->file, c) < 0)
      {  int errnum;
         const char *msg;
         fh->err = 1;
         msg = gzerror(fh->file, &errnum);
         if (errnum == Z_ERRNO)
            lib_err_msg(strerror(errno));
         else
            lib_err_msg(msg);
         c = XEOF;
      }
done: return c;
}

static int z_ferror(void *_fh)
{     struct z_file *fh = _fh;
      return fh->err;
}

static int z_feof(void *_fh)
{     struct z_file *fh = _fh;
      return fh->eof;
}

static int z_fflush(void *_fh)
{     struct z_file *fh = _fh;
      int ret;
      ret = gzflush(fh->file, Z_FINISH);
      if (ret == Z_OK)
         ret = 0;
      else
      {  int errnum;
         const char *msg;
         fh->err = 1;
         msg = gzerror(fh->file, &errnum);
         if (errnum == Z_ERRNO)
            lib_err_msg(strerror(errno));
         else
            lib_err_msg(msg);
         ret = XEOF;
      }
      return ret;
}

static int z_fclose(void *_fh)
{     struct z_file *fh = _fh;
      gzclose(fh->file);
      xfree(fh);
      return 0;
}

#endif

/* eof */