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

Generated on Fri Jan 14 2011 for SphinxBase by  doxygen 1.7.1