mes.c

General Hidden Markov Model Library 一个通用的隐马尔科夫模型的C代码库

/*******************************************************************************
*
*       This file is part of the General Hidden Markov Model Library,
*       GHMM version 0.8_beta1, see http://ghmm.org
*
*       Filename: ghmm/ghmm/mes.c
*       Authors:  Frank N黚el, Benjamin Georgi, Janne Grunau
*
*       Copyright (C) 1998-2004 Alexander Schliep
*       Copyright (C) 1998-2001 ZAIK/ZPR, Universitaet zu Koeln
*       Copyright (C) 2002-2004 Max-Planck-Institut fuer Molekulare Genetik,
*                               Berlin
*
*       Contact: [e-mail]
*
*       This library is free software; you can redistribute it and/or
*       modify it under the terms of the GNU Library General Public
*       License as published by the Free Software Foundation; either
*       version 2 of the License, or (at your option) any later version.
*
*       This library 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
*       Library General Public License for more details.
*
*       You should have received a copy of the GNU Library General Public
*       License along with this library; if not, write to the Free
*       Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
*
*       This file is version $Revision: 1435 $
*                       from $Date: 2005-10-12 13:12:42 +0200 (Wed, 12 Oct 2005) $
*             last change by $Author: grunau $.
*
*******************************************************************************/

#ifdef HAVE_CONFIG_H
#  include "../config.h"
#endif

#include <errno.h>
#include <string.h>
#include <time.h>

#ifdef WIN32
#  include <windows.h>
#  include <io.h>
#endif

#include "mes.h"
#include "mprintf.h"

/* from sys.h */

#if defined( _WINDOWS ) || defined( _DOS ) || defined(_PPC)
#  define strcasecmp( a, b ) strcmpi( a, b )
#  define PathSepChar ('\\')
#else
#  define PathSepChar ('/')
#endif


#define MAX_MES_FILE_LENGTH 1400000

static char *mes_err_txt[] = {
  "0 pointer",
  "negative value",
  "value out of range",
  "zero value",
  "boolean value FALSE"
};

typedef struct mes_t {
  int thread_id;
  char *std_path;
  char *logfile;
  int argc;
  char **argv;
  char win_enabled;
  char enabled;
  void (*win_fkt) (const char *);
} mes_t;

#define MES_PROCESS_MAX 0x10000
static mes_t *mes_process[MES_PROCESS_MAX];
static int mes_process_n = 0;

static char mes_default_logfile[] = "message.txt";
static char mes_default_bak_logfile[] = "message.bak";

/*static char*  mes_logfile = NULL;
static int    mes_argc = 0;
static char** mes_argv = NULL;

static char  mes_win_enabled = 1;
static char  mes_enabled = 1;
static void(*mes_win_fkt)(char*) = NULL;*/

/*---------------------------------------------------------------------------*/
static mes_t *mes_process_get (void)
{
  int i, tid = getthreadid ();
  for (i = mes_process_n - 1; i >= 0; i--)
    if (mes_process[i])
      if (mes_process[i]->thread_id == tid)
        return (mes_process[i]);
  return (NULL);
}                               /* mes_process_get */

/*---------------------------------------------------------------------------*/
static int mes_process_enabled (void)
{
  mes_t *mpc = mes_process_get ();
  if (mpc)
    return mpc->enabled;
  return (1);
}                               /* mes_process_enabled */

/*---------------------------------------------------------------------------*/
static int mes_process_win_enabled (void)
{
  mes_t *mpc = mes_process_get ();
  if (mpc)
    return mpc->win_enabled;
  return (1);
}                               /* mes_process_win_enabled */

/*---------------------------------------------------------------------------*/
char *ighmm_mes_get_std_path (void)
{
  mes_t *mpc = mes_process_get ();
  if (mpc)
    return mpc->std_path;
  return (NULL);
}                               /* ighmm_mes_get_std_path */

/*---------------------------------------------------------------------------*/
static void mes_process_alloc ()
{
  mes_t *mpi;
  int tid = getthreadid ();
  if (mes_process_get ())
    return;
  if (mes_process_n >= MES_PROCESS_MAX)
    return;
  if (!mes_process)
    return;
  else {
    int i, j = -1;
    for (i = mes_process_n - 1; i >= 0; i--)
      if (!mes_process[i]) {
        j = i;
        break;
      }
    if (i == -1 && mes_process_n < MES_PROCESS_MAX) {
      mpi = (mes_t *) calloc (1, sizeof (mes_t));
      if (!mpi)
        return;
      mes_process[mes_process_n++] = mpi;
    }
    else if (j >= 0) {
      mpi = (mes_t *) calloc (1, sizeof (mes_t));
      if (!mpi)
        return;
      mes_process[j] = mpi;
    }
    else
      return;
  }

  mpi->thread_id = tid;
  mpi->std_path = NULL;
  mpi->logfile = NULL;
  mpi->argc = 0;
  mpi->argv = NULL;

  mpi->win_enabled = 1;
  mpi->enabled = 1;
  mpi->win_fkt = NULL;
}                               /* mes_process_alloc */

/*---------------------------------------------------------------------------*/
static void mes_aux_va (int flags, char *format, va_list args)
{
  char str[1024];
  char *tmp;

  tmp = ighmm_mprintf_va_dyn (str, sizeof (str), format, args);
  if (!tmp)
    return;
  ighmm_mes_smart (flags, tmp, -1);
  if (tmp - str)
    free (tmp);
  return;
}                               /* mes_aux_va */

/*---------------------------------------------------------------------------*/
static void mes_aux (int flags, char *format, ...)
{
  va_list args;
  va_start (args, format);
  mes_aux_va (flags, format, args);
  return;
}                               /* mes_aux */

/*---------------------------------------------------------------------------*/
static int mes_filename_check (const char *filename)
{
  int len;

  if (!filename)
    return (-1);
  len = strlen (filename);
  if (len <= 0)
    return (-1);
#if defined(_WINDOWS)
  /* WORK AROUND !! 
     The following code line is included to catch an error of the 
     network driver of Windows NT. 
   */

  if (filename[len - 1] == '\\')
    return (-1);

  /* End of the work around */
#endif
  return (0);
}                               /* mes_filename_check */

/*---------------------------------------------------------------------------*/
static void mes_arg_free (void)
{
  mes_t *mpc = mes_process_get ();
  if (!mpc)
    return;
  if (mpc->argv) {
    while (mpc->argc > 0) {
      mpc->argc--;
      if (mpc->argv[mpc->argc])
        free (mpc->argv[mpc->argc]);
    }
    free (mpc->argv);
    mpc->argv = NULL;
  }
  mpc->argc = 0;
}                               /* mes_arg_free */

/*----------------------------------------------------------------------------*/
static void mes_init_std_path (char *logfile)
{
  mes_t *mpc = mes_process_get ();
  int i;

  if (mpc) {
    if (mpc->std_path)
      free (mpc->std_path);
    for (i = logfile ? strlen (logfile) : 0;
         i && logfile[i - 1] - PathSepChar; i--);
    mpc->std_path = malloc (i + 1);
    if (mpc->std_path) {
      memcpy (mpc->std_path, logfile, i);
      mpc->std_path[i] = '\0';
    }
  }
}                               /* mes_init_std_path */



/*============================================================================*/
void ighmm_mes_smart (int flags, const char *txt, int bytes)
{
  char tmp[2] = { 0 };
  int slen;

  if (!mes_process_enabled ())
    return;
  if (flags & MES_FLAG_TIME)
    ighmm_mes_time ();
  if (!txt)
    return;
  if (bytes < 0) {
    slen = strlen (txt);
    bytes = slen;
  }
  else {
    char *p = memchr (txt, 0, bytes);
    if (p)
      slen = txt - p;
    else
      slen = bytes + 1;
  }
  if (bytes <= 0)
    return;
  if (slen > bytes) {
    tmp[0] = txt[bytes - 1];
    tmp[bytes - 1] = 0;
  }

  if (flags & (MES_FLAG_FILE | MES_FLAG_TIME)) {
    FILE *fmes;
    int size;
    char *logfile = NULL;
    mes_t *mpc = mes_process_get ();
    if (mpc)
      logfile = mpc->logfile;

    if (!logfile)
      logfile = mes_default_logfile;
    fmes = fopen (logfile, "rb");
    if (fmes) {
      fseek (fmes, 0, SEEK_END);
      size = ftell (fmes);
      fclose (fmes);
      if (size > MAX_MES_FILE_LENGTH) {
        char bakfile[300];
        if (mpc && mpc->std_path)
          sprintf (bakfile, "%s%s", mpc->std_path, mes_default_bak_logfile);
        else
          sprintf (bakfile, "%s", mes_default_bak_logfile);
        remove (bakfile);
        if (rename (logfile, bakfile)) {
          mes_aux (MES_FLAG_WIN,
                   "\nFehler: Kann Datei %s nicht in %s umbenennen.\n\n",
                   logfile, bakfile);
        }
      }
    }

    fmes = fopen (logfile, "at");
    if (fmes) {
      fputs (txt, fmes);
      fputs (tmp, fmes);
      fclose (fmes);
    }
  }
  if ((flags & MES_FLAG_WIN) && mes_process_win_enabled ()) {
    mes_t *mpc = mes_process_get ();
    if (mpc && mpc->win_fkt) {
      (*mpc->win_fkt) (txt);
      (*mpc->win_fkt) (tmp);
    }

    else {
      fputs (txt, stdout);
      fputs (tmp, stdout);
      fflush (stdout);
    }
  }
  if (slen > bytes)
    ((char *) (txt))[bytes - 1] = tmp[0];
}                               /* ighmm_mes_smart */

/*============================================================================*/
void ighmm_mes_exit (void)
{
  int i, tid = getthreadid ();
  for (i = mes_process_n - 1; i >= 0; i--) {
    mes_t *mpi = mes_process[i];
    if (mpi)
      if (mpi->thread_id == tid) {
        if (mpi->logfile)
          free (mpi->logfile);
        if (mpi->std_path)
          free (mpi->std_path);
        mes_arg_free ();
        free (mpi);
        mes_process[i] = NULL;
        return;
      }
  }
}                               /* ighmm_mes_exit */

/*============================================================================*/
void ighmm_mes_init_args (int argc, char *argv[])
{
  mes_t *mpc = mes_process_get ();
  if (!argv || argc < 1)
    return;
  mes_arg_free ();
  mpc->argv = calloc (1, argc * sizeof (*mpc->argv));
  if (mpc->argv)
    while (mpc->argc < argc && *argv) {
      int len = *argv ? strlen (*argv) + 1 : 1;
      mpc->argv[mpc->argc] = malloc (len);
      if (!mpc->argv[mpc->argc])
        break;
      if (*argv)
        memcpy (mpc->argv[mpc->argc], *argv, len);
      else
        mpc->argv[mpc->argc][0] = 0;
      argv++;
      mpc->argc++;
    }
}                               /* ighmm_mes_init_args */

/*============================================================================*/
void ighmm_mes_init_logfile (char *logfile)
{
  FILE *tst;
  mes_t *mpc = mes_process_get ();

  if (!logfile)
    return;

  mes_init_std_path (logfile);

  tst = fopen (logfile, "at");
  if (tst) {
    fclose (tst);
    if (mpc) {
      int len = strlen (logfile);
      if (mpc->logfile)
        free (mpc->logfile);
      mpc->logfile = (char *) malloc (len + 1);
      if (mpc->logfile) {
        strcpy (mpc->logfile, logfile);
        mpc->logfile[len] = '\0';
      }
      return;
    }
  }
}                               /* ighmm_mes_init_logfile */

/*============================================================================*/
void ighmm_mes_init_winfct (void (*winfct) (const char *))
{
  mes_t *mpc = mes_process_get ();
  if (mpc && winfct)
    mpc->win_fkt = winfct;
}                               /* ighmm_mes_init_winfct */

/*============================================================================*/
void ighmm_mes_init (char *logfile, void (*winfct) (const char *), int argc,
               char *argv[])
{
  mes_process_alloc ();
  ighmm_mes_init_args (argc, argv);
  ighmm_mes_init_logfile (logfile);
  ighmm_mes_init_winfct (winfct);
}                               /* ighmm_mes_init */

/*============================================================================*/
int ighmm_mes_win_ability (int on)
{
  mes_t *mpc = mes_process_get ();
  if (mpc) {
    int res = mpc->win_enabled;
    mpc->win_enabled = !!on;
    return (res);
  }
  return (1);
}                               /* ighmm_mes_win_ability */

/*============================================================================*/
int ighmm_mes_ability (int on)
{
  mes_t *mpc = mes_process_get ();
  if (mpc) {
    int res = mpc->enabled;
    mpc->enabled = !!on;
    return (res);
  }
  return (1);
}                               /* ighmm_mes_ability */

/*============================================================================*/
void ighmm_mes_time (void)
{
  mes_t *mpc = mes_process_get ();
  time_t now = time (NULL);
  char *timestr = ctime (&now);
  int len = strlen (timestr);
  char txt[256];

  if (!len)
    return;
  if (timestr[len - 1] == '\n')
    timestr[len - 1] = ' ';
  mes_file ("\n***** ");
  if (mpc) {
    if (mpc->argc == 1) {
      mes_file (mpc->argv[0]);
      mes_file (":");
    }
    else if (mpc->argc > 1) {
      int i;
      mes_file (mpc->argv[0]);
      mes_file ("(");
      mes_file (mpc->argv[1]);
      for (i = 2; i < mpc->argc; i++) {
        mes_file (",");
        mes_file (mpc->argv[i]);
      }
      mes_file (")");
      mes_file (":");
    }
  }
  mes_file (timestr);
  sprintf (txt, "(%.2f sec)", clock () / (float) CLOCKS_PER_SEC);
  mes_file (txt);
  mes_file (" *****:\n");
}                               /* ighmm_mes_time */


/*============================================================================*/
void ighmm_mes_va (int flags, int line, char *xproc, char *proc, char *format,
             va_list args)
{
  char digstr[32] = { 0 };

  if (!format && !xproc && !proc)
    return;
  if (line + 1)
    ighmm_mprintf (digstr, sizeof (digstr), "(%u)", line);
  if (flags & MES_FLAG_TIME) {
    ighmm_mes_time ();
    flags &= ~MES_FLAG_TIME;
    flags |= MES_FLAG_FILE;
  }
  if (!xproc)
    xproc = proc;
  if (!proc)
    proc = xproc;
  if (proc) {
    if (flags & MES_FLAG_FILE)
      mes_file (xproc);
    if (flags & MES_FLAG_WIN)
      mes_win (proc);
    ighmm_mes_smart (flags, digstr, -1);
    if (format)
      ighmm_mes_smart (flags, ": ", -1);
  }

  if (!format)
    ighmm_mes_smart (flags, "\n", -1);
  else
    mes_aux_va (flags, format, args);
}                               /* ighmm_mes_va */

/*============================================================================*/
void ighmm_mes (int flags, int line, char *xproc, char *proc, char *format, ...)
{
  va_list args;
  va_start (args, format);
  ighmm_mes_va (flags, line, xproc, proc, format, args);
}                               /* ighmm_mes */

#ifdef GHMM_UNSUPORTED
/*============================================================================*/
void ighmm_mes_printf (int prot_flags, char *format, ...)
{
  va_list args;
  char *txt;

  if (!prot_flags)
    return;
  if (!format) {
    ighmm_mes_time ();
    mes_file ("Call of ighmm_mes_printf without format string");
    return;
  }
  va_start (args, format);
  txt = ighmm_mprintf_va (NULL, 0, format, args);
  if (!txt) {
    ighmm_mes_time ();
    mes_file_win ("Call of ighmm_mes_printf with format string\"");
    mes_file_win (format);
    mes_file_win ("\" without success\n");
    return;
  }
  if (prot_flags & MES_FLAG_TIME)
    ighmm_mes_time ();
  ighmm_mes_smart (prot_flags, txt, -1);
  free (txt);
}                               /* ighmm_mes_printf */

/*============================================================================*/
void ighmm_mes_fformat (char *txt, char *logfile, int line, char *proc_info)
{
  ighmm_mes_time ();
  if (proc_info && strlen (proc_info)) {
    ighmm_mes_smart (MES_FLAG_FILE, proc_info, -1);
    mes_file (":");
  }
  mes_file_win ("format error");
  if (logfile && strlen (logfile)) {
    mes_file_win (" in file ");