• Main Page
  • Related Pages
  • Data Structures
  • Files
  • File List
  • Globals

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 <stdio.h>
00043 #include <stdlib.h>
00044 #include <string.h>
00045 #include <errno.h>
00046 
00047 #include "err.h"
00048 #include "config.h"
00049 
00050 #ifdef SPHINX_DEBUG
00051 static int sphinx_debug_level;
00052 int
00053 err_set_debug_level(int level)
00054 {
00055     int prev = sphinx_debug_level;
00056     sphinx_debug_level = level;
00057     return prev;
00058 }
00059 int
00060 err_get_debug_level(void)
00061 {
00062     return sphinx_debug_level;
00063 }
00064 #else
00065 int
00066 err_set_debug_level(int level)
00067 {
00068     return 0;
00069 }
00070 
00071 int
00072 err_get_debug_level(void)
00073 {
00074     return 0;
00075 }
00076 #endif
00077 
00078 #if defined(HAVE_PTHREAD_H)
00079 #include <pthread.h>
00080 static pthread_key_t logfp_index;
00081 static pthread_once_t logfp_index_once = PTHREAD_ONCE_INIT;
00082 
00083 void
00084 logfp_index_alloc(void)
00085 {
00086     pthread_key_create(&logfp_index, NULL);
00087     pthread_setspecific(logfp_index, (void *)-1);
00088 }
00089 
00090 FILE *
00091 err_get_logfp(void)
00092 {
00093     FILE *logfp;
00094 
00095     pthread_once(&logfp_index_once, logfp_index_alloc);
00096     logfp = (FILE *)pthread_getspecific(logfp_index);
00097     if (logfp == (FILE *)-1)
00098         return stderr;
00099     else
00100         return logfp;
00101 }
00102 
00103 static void
00104 internal_set_logfp(FILE *fh)
00105 {
00106     pthread_setspecific(logfp_index, (void *)fh);
00107 }
00108 
00109 #elif defined(_WIN32) || defined(__CYGWIN__) /* Use Windows TLS on Cygwin */
00110 #include <windows.h>
00111 static DWORD logfp_index; 
00112 static LONG logfp_index_once = 0; 
00114 void
00115 logfp_index_alloc(void)
00116 {
00117     logfp_index = TlsAlloc();
00118     TlsSetValue(logfp_index, (void *)-1);
00119 }
00120 
00121 FILE *
00122 err_get_logfp(void)
00123 {
00124     FILE *logfp;
00125 
00126     if (InterlockedExchange(&logfp_index_once, 1) == 0)
00127         logfp_index_alloc();
00128     logfp = (FILE *)TlsGetValue(logfp_index);
00129     if (logfp == (FILE *)-1)
00130         return stderr;
00131     else
00132         return logfp;
00133 }
00134 
00135 static void
00136 internal_set_logfp(FILE *fh)
00137 {
00138     TlsSetValue(logfp_index, (void *)fh);
00139 }
00140 
00141 #else
00142 FILE *logfp = (FILE *)-1;
00143 
00144 FILE *
00145 err_get_logfp(void)
00146 {
00147     if (logfp == (FILE *)-1)
00148         return stderr;
00149     else
00150         return logfp;
00151 }
00152 
00153 static void
00154 internal_set_logfp(FILE *fh)
00155 {
00156     logfp = fh;
00157 }
00158 
00159 #endif
00160  
00161 FILE *
00162 err_set_logfp(FILE *newfp)
00163 {
00164     FILE *oldfp;
00165 
00166     oldfp = err_get_logfp();
00167     internal_set_logfp(newfp);
00168 
00169     return oldfp;
00170 }
00171 
00172 int
00173 err_set_logfile(char const *file)
00174 {
00175     FILE *newfp, *oldfp;
00176 
00177     if ((newfp = fopen(file, "a")) == NULL)
00178         return -1;
00179     oldfp = err_get_logfp();
00180     internal_set_logfp(newfp);
00181     if (oldfp != NULL && oldfp != stdout && oldfp != stderr)
00182         fclose(oldfp);
00183     return 0;
00184 }
00185 
00186 
00187 void
00188 _E__pr_info_header_wofn(char const *msg)
00189 {
00190     FILE *logfp;
00191 
00192     logfp = err_get_logfp();
00193     if (logfp == NULL)
00194         return;
00195     /* make different format so as not to be parsed by emacs compile */
00196     fprintf(logfp, "%s:\t", msg);
00197     fflush(logfp);
00198 }
00199 
00200 void
00201 _E__pr_header(char const *f, long ln, char const *msg)
00202 {
00203     char const *fname;
00204     FILE *logfp;
00205 
00206     logfp = err_get_logfp();
00207     if (logfp == NULL)
00208         return;
00209     fname = strrchr(f,'\\');
00210     if (fname == NULL)
00211         fname = strrchr(f,'/');
00212     fprintf(logfp, "%s: \"%s\", line %ld: ", msg, fname == NULL ? f : fname + 1, ln);
00213     fflush(logfp);
00214 }
00215 
00216 void
00217 _E__pr_info_header(char const *f, long ln, char const *msg)
00218 {
00219     char const *fname;
00220     FILE *logfp;
00221 
00222     logfp = err_get_logfp();
00223     if (logfp == NULL)
00224         return;
00225     fname = strrchr(f,'\\');
00226     if (fname == NULL)
00227         fname = strrchr(f,'/');
00228     /* make different format so as not to be parsed by emacs compile */
00229     fprintf(logfp, "%s: %s(%ld): ", msg, fname == NULL ? f : fname + 1, ln);
00230     fflush(logfp);
00231 }
00232 
00233 void
00234 _E__pr_warn(char const *fmt, ...)
00235 {
00236     va_list pvar;
00237     FILE *logfp;
00238 
00239     logfp = err_get_logfp();
00240     if (logfp == NULL)
00241         return;
00242     va_start(pvar, fmt);
00243     vfprintf(logfp, fmt, pvar);
00244     va_end(pvar);
00245 
00246     fflush(logfp);
00247 }
00248 
00249 void
00250 _E__pr_info(char const *fmt, ...)
00251 {
00252     va_list pvar;
00253     FILE *logfp;
00254 
00255     logfp = err_get_logfp();
00256     if (logfp == NULL)
00257         return;
00258     va_start(pvar, fmt);
00259     vfprintf(logfp, fmt, pvar);
00260     va_end(pvar);
00261 
00262     fflush(logfp);
00263 }
00264 
00265 void
00266 _E__die_error(char const *fmt, ...)
00267 {
00268     va_list pvar;
00269     FILE *logfp;
00270 
00271     logfp = err_get_logfp();
00272     if (logfp) {
00273         va_start(pvar, fmt);
00274         vfprintf(logfp, fmt, pvar);
00275         va_end(pvar);
00276         fflush(logfp);
00277     }
00278 
00279 #if defined(__ADSPBLACKFIN__) && !defined(__linux__)
00280     while(1);
00281 #else 
00282         exit(-1);
00283 #endif
00284 }
00285 
00286 void
00287 _E__fatal_sys_error(char const *fmt, ...)
00288 {
00289     va_list pvar;
00290     FILE *logfp;
00291     int local_errno = errno;
00292 
00293     logfp = err_get_logfp();
00294     if (logfp) {
00295         va_start(pvar, fmt);
00296         vfprintf(logfp, fmt, pvar);
00297         va_end(pvar);
00298 
00299         fprintf(logfp, "; %s\n", strerror(local_errno));
00300         fflush(logfp);
00301     }
00302 
00303 
00304 #if defined(__ADSPBLACKFIN__) && !defined(__linux__)
00305     while(1);
00306 #else 
00307         exit(-1);
00308 #endif
00309 
00310 }
00311 
00312 void
00313 _E__sys_error(char const *fmt, ...)
00314 {
00315     va_list pvar;
00316     FILE *logfp;
00317     int local_errno = errno;
00318 
00319     logfp = err_get_logfp();
00320     if (logfp == NULL)
00321         return;
00322 
00323     va_start(pvar, fmt);
00324     vfprintf(logfp, fmt, pvar);
00325     va_end(pvar);
00326 
00327     fprintf(logfp, "; %s\n", strerror(local_errno));
00328     fflush(logfp);
00329 }
00330 
00331 void
00332 _E__abort_error(char const *fmt, ...)
00333 {
00334     va_list pvar;
00335     FILE *logfp;
00336 
00337     logfp = err_get_logfp();
00338     if (logfp) {
00339         va_start(pvar, fmt);
00340         vfprintf(logfp, fmt, pvar);
00341         va_end(pvar);
00342         fflush(logfp);
00343     }
00344 
00345 #if defined(__ADSPBLACKFIN__) && !defined(__linux__)
00346 while(1);
00347 #elif defined(_WIN32_WCE)
00348 exit(-1);
00349 #else
00350 abort();
00351 #endif
00352 
00353 }

Generated on Mon Aug 29 2011 for SphinxBase by  doxygen 1.7.1