SphinxBase  0.6
src/libsphinxbase/util/err.c
Go to the documentation of this file.
00001 /* -*- c-basic-offset: 4; indent-tabs-mode: nil -*- */
00002 /* ====================================================================
00003  * Copyright (c) 1999-2004 Carnegie Mellon University.  All rights
00004  * reserved.
00005  *
00006  * Redistribution and use in source and binary forms, with or without
00007  * modification, are permitted provided that the following conditions
00008  * are met:
00009  *
00010  * 1. Redistributions of source code must retain the above copyright
00011  *    notice, this list of conditions and the following disclaimer. 
00012  *
00013  * 2. Redistributions in binary form must reproduce the above copyright
00014  *    notice, this list of conditions and the following disclaimer in
00015  *    the documentation and/or other materials provided with the
00016  *    distribution.
00017  *
00018  * This work was supported in part by funding from the Defense Advanced 
00019  * Research Projects Agency and the National Science Foundation of the 
00020  * United States of America, and the CMU Sphinx Speech Consortium.
00021  *
00022  * THIS SOFTWARE IS PROVIDED BY CARNEGIE MELLON UNIVERSITY ``AS IS'' AND 
00023  * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, 
00024  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
00025  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL CARNEGIE MELLON UNIVERSITY
00026  * NOR ITS EMPLOYEES BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
00027  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
00028  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 
00029  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 
00030  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
00031  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
00032  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
00033  *
00034  * ====================================================================
00035  *
00036  */
00042 #include "config.h"
00043 
00044 #include <stdio.h>
00045 #include <stdlib.h>
00046 #include <stdarg.h>
00047 #include <string.h>
00048 #include <errno.h>
00049 
00050 #include "sphinxbase/err.h"
00051 
00052 #ifdef SPHINX_DEBUG
00053 static int sphinx_debug_level;
00054 int
00055 err_set_debug_level(int level)
00056 {
00057     int prev = sphinx_debug_level;
00058     sphinx_debug_level = level;
00059     return prev;
00060 }
00061 int
00062 err_get_debug_level(void)
00063 {
00064     return sphinx_debug_level;
00065 }
00066 #else
00067 int
00068 err_set_debug_level(int level)
00069 {
00070     return 0;
00071 }
00072 
00073 int
00074 err_get_debug_level(void)
00075 {
00076     return 0;
00077 }
00078 #endif
00079 
00080 #if defined(HAVE_PTHREAD_H)
00081 #include <pthread.h>
00082 static pthread_key_t logfp_index;
00083 static pthread_once_t logfp_index_once = PTHREAD_ONCE_INIT;
00084 
00085 void
00086 logfp_index_alloc(void)
00087 {
00088     pthread_key_create(&logfp_index, NULL);
00089 }
00090 
00091 FILE *
00092 err_get_logfp(void)
00093 {
00094     FILE *logfp;
00095 
00096     pthread_once(&logfp_index_once, logfp_index_alloc);
00097     logfp = (FILE *)pthread_getspecific(logfp_index);
00098 
00099     if (logfp == NULL)
00100         return stderr;
00101     else if (logfp == (FILE*) -1)
00102         return NULL;
00103     else
00104         return logfp;
00105 }
00106 
00107 static void
00108 internal_set_logfp(FILE *fh)
00109 {
00110     if (fh == NULL)
00111         fh = (FILE*) -1;
00112 
00113     pthread_setspecific(logfp_index, (void *)fh);
00114 }
00115 
00116 #elif defined(_WIN32) || defined(__CYGWIN__) /* Use Windows TLS on Cygwin */
00117 #include <windows.h>
00118 static DWORD logfp_index; 
00119 static LONG logfp_index_once = 0; 
00121 void
00122 logfp_index_alloc(void)
00123 {
00124     logfp_index = TlsAlloc();
00125 }
00126 
00127 FILE *
00128 err_get_logfp(void)
00129 {
00130     FILE *logfp;
00131 
00132     if (InterlockedExchange(&logfp_index_once, 1) == 0)
00133         logfp_index_alloc();
00134     logfp = (FILE *)TlsGetValue(logfp_index);
00135 
00136     if (logfp == NULL)
00137         return stderr;
00138     else if (logfp == (FILE*) -1)
00139         return NULL;
00140     else
00141         return logfp;
00142 }
00143 
00144 static void
00145 internal_set_logfp(FILE *fh)
00146 {
00147     if (fh == NULL)
00148         fh = (FILE*) -1;
00149 
00150     TlsSetValue(logfp_index, (void *)fh);
00151 }
00152 
00153 #else
00154 FILE *logfp = NULL;
00155 
00156 FILE *
00157 err_get_logfp(void)
00158 {
00159     if (logfp == NULL)
00160         return stderr;
00161     else if (logfp == (FILE*) -1)
00162         return NULL;
00163     else
00164         return logfp;
00165 }
00166 
00167 static void
00168 internal_set_logfp(FILE *fh)
00169 {
00170     if (fh == NULL)
00171         fh = (FILE*) -1;
00172 
00173     logfp = fh;
00174 }
00175 
00176 #endif
00177  
00178 FILE *
00179 err_set_logfp(FILE *newfp)
00180 {
00181     FILE *oldfp;
00182 
00183     oldfp = err_get_logfp();
00184     internal_set_logfp(newfp);
00185 
00186     return oldfp;
00187 }
00188 
00189 int
00190 err_set_logfile(char const *file)
00191 {
00192     FILE *newfp, *oldfp;
00193 
00194     if ((newfp = fopen(file, "a")) == NULL)
00195         return -1;
00196     oldfp = err_get_logfp();
00197     internal_set_logfp(newfp);
00198     if (oldfp != NULL && oldfp != stdout && oldfp != stderr)
00199         fclose(oldfp);
00200     return 0;
00201 }
00202 
00203 
00204 void
00205 _E__pr_info_header_wofn(char const *msg)
00206 {
00207     FILE *logfp;
00208 
00209     logfp = err_get_logfp();
00210     if (logfp == NULL)
00211         return;
00212     /* make different format so as not to be parsed by emacs compile */
00213     fprintf(logfp, "%s:\t", msg);
00214     fflush(logfp);
00215 }
00216 
00217 void
00218 _E__pr_header(char const *f, long ln, char const *msg)
00219 {
00220     char const *fname;
00221     FILE *logfp;
00222 
00223     logfp = err_get_logfp();
00224     if (logfp == NULL)
00225         return;
00226     fname = strrchr(f,'\\');
00227     if (fname == NULL)
00228         fname = strrchr(f,'/');
00229     fprintf(logfp, "%s: \"%s\", line %ld: ", msg, fname == NULL ? f : fname + 1, ln);
00230     fflush(logfp);
00231 }
00232 
00233 void
00234 _E__pr_info_header(char const *f, long ln, char const *msg)
00235 {
00236     char const *fname;
00237     FILE *logfp;
00238 
00239     logfp = err_get_logfp();
00240     if (logfp == NULL)
00241         return;
00242     fname = strrchr(f,'\\');
00243     if (fname == NULL)
00244         fname = strrchr(f,'/');
00245     /* make different format so as not to be parsed by emacs compile */
00246     fprintf(logfp, "%s: %s(%ld): ", msg, fname == NULL ? f : fname + 1, ln);
00247     fflush(logfp);
00248 }
00249 
00250 void
00251 _E__pr_warn(char const *fmt, ...)
00252 {
00253     va_list pvar;
00254     FILE *logfp;
00255 
00256     logfp = err_get_logfp();
00257     if (logfp == NULL)
00258         return;
00259     va_start(pvar, fmt);
00260     vfprintf(logfp, fmt, pvar);
00261     va_end(pvar);
00262 
00263     fflush(logfp);
00264 }
00265 
00266 void
00267 _E__pr_info(char const *fmt, ...)
00268 {
00269     va_list pvar;
00270     FILE *logfp;
00271 
00272     logfp = err_get_logfp();
00273     if (logfp == NULL)
00274         return;
00275     va_start(pvar, fmt);
00276     vfprintf(logfp, fmt, pvar);
00277     va_end(pvar);
00278 
00279     fflush(logfp);
00280 }
00281 
00282 void
00283 _E__die_error(char const *fmt, ...)
00284 {
00285     va_list pvar;
00286     FILE *logfp;
00287 
00288     logfp = err_get_logfp();
00289     if (logfp) {
00290         va_start(pvar, fmt);
00291         vfprintf(logfp, fmt, pvar);
00292         va_end(pvar);
00293         fflush(logfp);
00294     }
00295 
00296 #if defined(__ADSPBLACKFIN__) && !defined(__linux__)
00297     while(1);
00298 #else 
00299         exit(-1);
00300 #endif
00301 }
00302 
00303 void
00304 _E__fatal_sys_error(char const *fmt, ...)
00305 {
00306     va_list pvar;
00307     FILE *logfp;
00308     int local_errno = errno;
00309 
00310     logfp = err_get_logfp();
00311     if (logfp) {
00312         va_start(pvar, fmt);
00313         vfprintf(logfp, fmt, pvar);
00314         va_end(pvar);
00315 
00316         fprintf(logfp, ": %s\n", strerror(local_errno));
00317         fflush(logfp);
00318     }
00319 
00320 
00321 #if defined(__ADSPBLACKFIN__) && !defined(__linux__)
00322     while(1);
00323 #else 
00324         exit(-1);
00325 #endif
00326 
00327 }
00328 
00329 void
00330 _E__sys_error(char const *fmt, ...)
00331 {
00332     va_list pvar;
00333     FILE *logfp;
00334     int local_errno = errno;
00335 
00336     logfp = err_get_logfp();
00337     if (logfp == NULL)
00338         return;
00339 
00340     va_start(pvar, fmt);
00341     vfprintf(logfp, fmt, pvar);
00342     va_end(pvar);
00343 
00344     fprintf(logfp, "; %s\n", strerror(local_errno));
00345     fflush(logfp);
00346 }
00347 
00348 void
00349 _E__abort_error(char const *fmt, ...)
00350 {
00351     va_list pvar;
00352     FILE *logfp;
00353 
00354     logfp = err_get_logfp();
00355     if (logfp) {
00356         va_start(pvar, fmt);
00357         vfprintf(logfp, fmt, pvar);
00358         va_end(pvar);
00359         fflush(logfp);
00360     }
00361 
00362 #if defined(__ADSPBLACKFIN__) && !defined(__linux__)
00363 while(1);
00364 #elif defined(_WIN32_WCE)
00365 exit(-1);
00366 #else
00367 abort();
00368 #endif
00369 
00370 }