/* glpenv01.c (environment initialization/termination) */

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

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

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

 #include "glpapi.h"

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

 *  NAME

 *

 *  glp_init_env - initialize GLPK environment

 *

 *  SYNOPSIS

 *

 *  int glp_init_env(void);

 *

 *  DESCRIPTION

 *

 *  The routine glp_init_env initializes the GLPK environment. Normally

 *  the application program does not need to call this routine, because

 *  it is called automatically on the first call to any API routine.

 *

 *  RETURNS

 *

 *  The routine glp_init_env returns one of the following codes:

 *

 *  0 - initialization successful;

 *  1 - environment has been already initialized;

 *  2 - initialization failed (insufficient memory);

 *  3 - initialization failed (unsupported programming model). */

 int glp_init_env(void)

 {     ENV *env;

       int ok;

       /* check if the programming model is supported */

       ok = (CHAR_BIT == 8 && sizeof(char) == 1 &&

          sizeof(short) == 2 && sizeof(int) == 4 &&

          (sizeof(void *) == 4 || sizeof(void *) == 8));

       if (!ok) return 3;

       /* check if the environment is already initialized */

       if (tls_get_ptr() != NULL) return 1;

       /* allocate and initialize the environment block */

       env = malloc(sizeof(ENV));

       if (env == NULL) return 2;

       env->magic = ENV_MAGIC;

       sprintf(env->version, "%d.%d",

          GLP_MAJOR_VERSION, GLP_MINOR_VERSION);

       env->term_buf = malloc(TERM_BUF_SIZE);

       if (env->term_buf == NULL)

       {  free(env);

          return 2;

       }

       env->term_out = GLP_ON;

       env->term_hook = NULL;

       env->term_info = NULL;

       env->tee_file = NULL;

       env->err_file = "";

       env->err_line = 0;

       env->err_hook = NULL;

       env->err_info = NULL;

       env->mem_limit.hi = 0x7FFFFFFF, env->mem_limit.lo = 0xFFFFFFFF;

       env->mem_ptr = NULL;

       env->mem_count = env->mem_cpeak = 0;

       env->mem_total = env->mem_tpeak = xlset(0);

       env->file_ptr = NULL;

       env->ioerr_msg = malloc(IOERR_MSG_SIZE);

       if (env->ioerr_msg == NULL)

       {  free(env->term_buf);

          free(env);

          return 2;

       }

       strcpy(env->ioerr_msg, "No error");

       env->h_odbc = env->h_mysql = NULL;

       /* save pointer to the environment block */

       tls_set_ptr(env);

       /* initialization successful */

       return 0;

 }

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

 *  NAME

 *

 *  get_env_ptr - retrieve pointer to environment block

 *

 *  SYNOPSIS

 *

 *  #include "glpenv.h"

 *  ENV *get_env_ptr(void);

 *

 *  DESCRIPTION

 *

 *  The routine get_env_ptr retrieves and returns a pointer to the GLPK

 *  environment block.

 *

 *  If the GLPK environment has not been initialized yet, the routine

 *  performs initialization. If initialization fails, the routine prints

 *  an error message to stderr and terminates the program.

 *

 *  RETURNS

 *

 *  The routine returns a pointer to the environment block. */

 ENV *get_env_ptr(void)

 {     ENV *env = tls_get_ptr();

       /* check if the environment has been initialized */

       if (env == NULL)

       {  /* not initialized yet; perform initialization */

          if (glp_init_env() != 0)

          {  /* initialization failed; display an error message */

             fprintf(stderr, "GLPK initialization failed\n");

             fflush(stderr);

             /* and abnormally terminate the program */

             abort();

          }

          /* initialization successful; retrieve the pointer */

          env = tls_get_ptr();

       }

       /* check if the environment block is valid */

       if (env->magic != ENV_MAGIC)

       {  fprintf(stderr, "Invalid GLPK environment\n");

          fflush(stderr);

          abort();

       }

       return env;

 }

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

 *  NAME

 *

 *  glp_version - determine library version

 *

 *  SYNOPSIS

 *

 *  const char *glp_version(void);

 *

 *  RETURNS

 *

 *  The routine glp_version returns a pointer to a null-terminated

 *  character string, which specifies the version of the GLPK library in

 *  the form "X.Y", where X is the major version number, and Y is the

 *  minor version number, for example, "4.16". */

 const char *glp_version(void)

 {     ENV *env = get_env_ptr();

       return env->version;

 }

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

 *  NAME

 *

 *  glp_free_env - free GLPK environment

 *

 *  SYNOPSIS

 *

 *  int glp_free_env(void);

 *

 *  DESCRIPTION

 *

 *  The routine glp_free_env frees all resources used by GLPK routines

 *  (memory blocks, etc.) which are currently still in use.

 *

 *  Normally the application program does not need to call this routine,

 *  because GLPK routines always free all unused resources. However, if

 *  the application program even has deleted all problem objects, there

 *  will be several memory blocks still allocated for the library needs.

 *  For some reasons the application program may want GLPK to free this

 *  memory, in which case it should call glp_free_env.

 *

 *  Note that a call to glp_free_env invalidates all problem objects as

 *  if no GLPK routine were called.

 *

 *  RETURNS

 *

 *  0 - termination successful;

 *  1 - environment is inactive (was not initialized). */

 int glp_free_env(void)

 {     ENV *env = tls_get_ptr();

       MEM *desc;

       /* check if the environment is active */

       if (env == NULL) return 1;

       /* check if the environment block is valid */

       if (env->magic != ENV_MAGIC)

       {  fprintf(stderr, "Invalid GLPK environment\n");

          fflush(stderr);

          abort();

       }

       /* close handles to shared libraries */

       if (env->h_odbc != NULL)

          xdlclose(env->h_odbc);

       if (env->h_mysql != NULL)

          xdlclose(env->h_mysql);

       /* close streams which are still open */

       while (env->file_ptr != NULL)

          xfclose(env->file_ptr);

       /* free memory blocks which are still allocated */

       while (env->mem_ptr != NULL)

       {  desc = env->mem_ptr;

          env->mem_ptr = desc->next;

          free(desc);

       }

       /* invalidate the environment block */

       env->magic = -1;

       /* free memory allocated to the environment block */

       free(env->term_buf);

       free(env->ioerr_msg);

       free(env);

       /* reset a pointer to the environment block */

       tls_set_ptr(NULL);

       /* termination successful */

       return 0;

 }

 /* eof */