/* glpenv.h (GLPK environment) */

/***********************************************************************

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

***********************************************************************/

#ifndef GLPENV_H

#define GLPENV_H

#include "glpstd.h"

#include "glplib.h"

typedef struct ENV ENV;

typedef struct MEM MEM;

typedef struct XFILE XFILE;

#define ENV_MAGIC 0x454E5631

/* environment block magic value */

#define TERM_BUF_SIZE 4096

/* terminal output buffer size, in bytes */

#define IOERR_MSG_SIZE 1024

/* i/o error message buffer size, in bytes */

#define MEM_MAGIC 0x4D454D31

/* memory block descriptor magic value */

struct ENV

{     /* environment block */

      int magic;

      /* magic value used for debugging */

      char version[7+1];

      /* version string returned by the routine glp_version */

      /*--------------------------------------------------------------*/

      /* terminal output */

      char *term_buf; /* char term_buf[TERM_BUF_SIZE]; */

      /* terminal output buffer */

      int term_out;

      /* flag to enable/disable terminal output */

      int (*term_hook)(void *info, const char *s);

      /* user-defined routine to intercept terminal output */

      void *term_info;

      /* transit pointer (cookie) passed to the routine term_hook */

      FILE *tee_file;

      /* output stream used to copy terminal output */

      /*--------------------------------------------------------------*/

      /* error handling */

      const char *err_file;

      /* value of the __FILE__ macro passed to glp_error */

      int err_line;

      /* value of the __LINE__ macro passed to glp_error */

      void (*err_hook)(void *info);

      /* user-defined routine to intercept abnormal termination */

      void *err_info;

      /* transit pointer (cookie) passed to the routine err_hook */

      /*--------------------------------------------------------------*/

      /* memory allocation */

      glp_long mem_limit;

      /* maximal amount of memory (in bytes) available for dynamic

         allocation */

      MEM *mem_ptr;

      /* pointer to the linked list of allocated memory blocks */

      int mem_count;

      /* total number of currently allocated memory blocks */

      int mem_cpeak;

      /* peak value of mem_count */

      glp_long mem_total;

      /* total amount of currently allocated memory (in bytes; is the

         sum of the size field over all memory block descriptors) */

      glp_long mem_tpeak;

      /* peak value of mem_total */

      /*--------------------------------------------------------------*/

      /* stream input/output */

      XFILE *file_ptr;

      /* pointer to the linked list of active stream descriptors */

      char *ioerr_msg; /* char ioerr_msg[IOERR_MSG_SIZE]; */

      /* input/output error message buffer */

      /*--------------------------------------------------------------*/

      /* shared libraries support */

      void *h_odbc;

      /* handle to ODBC shared library */

      void *h_mysql;

      /* handle to MySQL shared library */

};

struct MEM

{     /* memory block descriptor */

      int flag;

      /* descriptor flag */

      int size;

      /* size of block (in bytes, including descriptor) */

      MEM *prev;

      /* pointer to previous memory block descriptor */

      MEM *next;

      /* pointer to next memory block descriptor */

};

struct XFILE

{     /* input/output stream descriptor */

      int type;

      /* stream handle type: */

#define FH_FILE   0x11  /* FILE   */

#define FH_ZLIB   0x22  /* gzFile */

      void *fh;

      /* pointer to stream handle */

      XFILE *prev;

      /* pointer to previous stream descriptor */

      XFILE *next;

      /* pointer to next stream descriptor */

};

#define XEOF (-1)

#define get_env_ptr _glp_get_env_ptr

ENV *get_env_ptr(void);

/* retrieve pointer to environment block */

#define tls_set_ptr _glp_tls_set_ptr

void tls_set_ptr(void *ptr);

/* store global pointer in TLS */

#define tls_get_ptr _glp_tls_get_ptr

void *tls_get_ptr(void);

/* retrieve global pointer from TLS */

#define xprintf glp_printf

void glp_printf(const char *fmt, ...);

/* write formatted output to the terminal */

#define xvprintf glp_vprintf

void glp_vprintf(const char *fmt, va_list arg);

/* write formatted output to the terminal */

#ifndef GLP_ERROR_DEFINED

#define GLP_ERROR_DEFINED

typedef void (*_glp_error)(const char *fmt, ...);

#endif

#define xerror glp_error_(__FILE__, __LINE__)

_glp_error glp_error_(const char *file, int line);

/* display error message and terminate execution */

#define xassert(expr) \

      ((void)((expr) || (glp_assert_(#expr, __FILE__, __LINE__), 1)))

void glp_assert_(const char *expr, const char *file, int line);

/* check for logical condition */

#define xmalloc glp_malloc

void *glp_malloc(int size);

/* allocate memory block */

#define xcalloc glp_calloc

void *glp_calloc(int n, int size);

/* allocate memory block */

#define xfree glp_free

void glp_free(void *ptr);

/* free memory block */

#define xtime glp_time

glp_long glp_time(void);

/* determine current universal time */

#define xdifftime glp_difftime

double glp_difftime(glp_long t1, glp_long t0);

/* compute difference between two time values, in seconds */

#define lib_err_msg _glp_lib_err_msg

void lib_err_msg(const char *msg);

#define xerrmsg _glp_lib_xerrmsg

const char *xerrmsg(void);

#define xfopen _glp_lib_xfopen

XFILE *xfopen(const char *fname, const char *mode);

#define xferror _glp_lib_xferror

int xferror(XFILE *file);

#define xfeof _glp_lib_xfeof

int xfeof(XFILE *file);

#define xfgetc _glp_lib_xfgetc

int xfgetc(XFILE *file);

#define xfputc _glp_lib_xfputc

int xfputc(int c, XFILE *file);

#define xfflush _glp_lib_xfflush

int xfflush(XFILE *fp);

#define xfclose _glp_lib_xfclose

int xfclose(XFILE *file);

#define xfprintf _glp_lib_xfprintf

int xfprintf(XFILE *file, const char *fmt, ...);

#define xdlopen _glp_xdlopen

void *xdlopen(const char *module);

#define xdlsym _glp_xdlsym

void *xdlsym(void *h, const char *symbol);

#define xdlclose _glp_xdlclose

void xdlclose(void *h);

#endif

/* eof */