All the new audio stuff.

[jog] / err.c

/* -*-c-*-
 *
 * $Id: err.c,v 1.1 2002/01/25 19:34:45 mdw Exp $
 *
 * Error reporting
 *
 * (c) 2001 Mark Wooding
 */

/*----- Licensing notice --------------------------------------------------* 
 *
 * This file is part of Jog: Programming for a jogging machine.
 *
 * Jog 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 2 of the License, or
 * (at your option) any later version.
 * 
 * Jog 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 Jog; if not, write to the Free Software Foundation,
 * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */

/*----- Revision history --------------------------------------------------* 
 *
 * $Log: err.c,v $
 * Revision 1.1  2002/01/25 19:34:45  mdw
 * Initial revision
 *
 */

/*----- Header files ------------------------------------------------------*/

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

#include <errno.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>

#include <mLib/exc.h>
#include <mLib/quis.h>

/* #include "au.h" */
#include "err.h"

/*----- Static variables --------------------------------------------------*/

static FILE *logfp = 0;
static unsigned flags = 0;

#define f_thread 1u

/*----- Main code ---------------------------------------------------------*/

/* --- @err_abort@ --- *
 *
 * Arguments:	@int reason@ = abort reason code
 *		@unsigned long err@ = abort error code
 *		@const char *msg@ = error message
 *
 * Returns:	Doesn't.
 *
 * Use:		Reports a fatal error.
 */

void err_abortv(int reason, unsigned long err, const char *msg, va_list *ap)
{
  fprintf(stderr, "%s: fatal error (code %d-%lu): ", QUIS, reason, err);
  vfprintf(stderr, msg, *ap);
  putc('\n', stderr);
  /* au_abort(reason, err); */
  abort();
}

void err_abort(int reason, unsigned long err, const char *msg, ...)
{
  va_list ap;

  va_start(ap, msg);
  err_abortv(reason, err, msg, &ap);
  va_end(ap);
}

/* --- @err_init@ --- *
 *
 * Arguments:	---
 *
 * Returns:	---
 *
 * Use:		Attempts to initialize the logging system.  It is a
 *		catastrophic failure if logging can't start up.
 */

static void err_exc(exc_extype ex, exc_exval v)
{
  switch (ex) {
    case EXC_NOMEM:
      err_report(ERR_EXC, 0, ex, "out of memory");
      break;
    default:
      err_report(ERR_EXC, 0, ex, "uncaught mLib exception");
      break;
  }
  exit(EXIT_FAILURE);
}

void err_init(void)
{
  const char *lf;

  lf = getenv("JOG_LOGFILE");
  if (!lf)
    logfp = stderr;
  else if ((logfp = fopen(lf, "w")) == 0) {
    err_abort(ERRABORT_LOGOPEN, errno,
	      "couldn't open logfile `%s': %s", lf, strerror(errno));
  }
  exc_uncaught(err_exc);
}

/* --- @err_report@ --- *
 *
 * Arguments:	@int ctx@ = context code
 *		@int reason@ = reason code
 *		@unsigned long err@ = system error code
 *		@const char *msg@ = textual message to log
 *
 * Returns:	---
 *
 * Use:		Reports an error.  Doesn't abort anything unless something
 *		really serious happens.
 */

void err_reportv(int ctx, int reason, unsigned long err,
		 const char *msg, va_list *ap)
{
  char buf[256];
  time_t t;
  struct tm *tm;

  if (ctx && !(flags & f_thread)) {
    unsigned f = flags;
    flags |= f_thread;
/*     au_misc(AU_ERROR, ctx, reason, err); */
    flags = f;
  }
  t = time(0);
  tm = localtime(&t);
  strftime(buf, sizeof(buf), "%Y-%m-%d %H:%M:%S", tm);
  if (fputs(buf, logfp) == EOF ||
      fprintf(stderr, " %s: ", QUIS) == EOF ||
      vfprintf(logfp, msg, *ap) == EOF ||
      (ctx && (fprintf(logfp, " (error %d", ctx) == EOF ||
	       (reason && fprintf(logfp, "-%d", reason) == EOF) ||
	       (err && fprintf(logfp, ":%lu", err) == EOF) ||
	       putc(')', logfp) == EOF)) ||
      putc('\n', logfp) == EOF ||
      fflush(logfp) == EOF) {
    err_abort(ERRABORT_LOGWRITE, errno,
	      "error writing logfile: %s", strerror(errno));
  }
}

void err_report(int ctx, int reason, unsigned long err, const char *msg, ...)
{
  va_list ap;

  va_start(ap, msg);
  err_reportv(ctx, reason, err, msg, &ap);
  va_end(ap);
}

/* --- @err_log@ --- *
 *
 * Arguments:	 @const char *msg@ = textual message to log
 *
 * Returns:	---
 *
 * Use:		Logs a message.
 */

void err_logv(const char *msg, va_list *ap)
{
  err_reportv(0, 0, 0, msg, ap);
}

void err_log(const char *msg, ...)
{
  va_list ap;

  va_start(ap, msg);
  err_reportv(0, 0, 0, msg, &ap);
  va_end(ap);
}

/*----- That's all, folks -------------------------------------------------*/