/* 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 */