Open64: osprey/be/opt/opt_error.c Source File

00001 /*
00002  * Copyright 2003, 2004, 2005, 2006 PathScale, Inc.  All Rights Reserved.
00003  */
00004 
00005 /* ====================================================================
00006  * ====================================================================
00007  *
00008  * Module: opt_error.c
00009  * $Revision: 1.1.1.1 $
00010  * $Date: 2005/10/21 19:00:00 $
00011  * $Author: marcel $
00012  * $Source: /proj/osprey/CVS/open64/osprey1.0/be/opt/opt_error.c,v $
00013  *
00014  * Revision history:
00015  *  30-AUG-94 - Original Version
00016  *
00017  * ====================================================================
00018  *
00019  * Copyright (C) 2000, 2001 Silicon Graphics, Inc.  All Rights Reserved.
00020  *
00021  * This program is free software; you can redistribute it and/or modify
00022  * it under the terms of version 2 of the GNU General Public License as
00023  * published by the Free Software Foundation.
00024  *
00025  * This program is distributed in the hope that it would be useful, but
00026  * WITHOUT ANY WARRANTY; without even the implied warranty of
00027  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
00028  *
00029  * Further, this software is distributed without any warranty that it
00030  * is free of the rightful claim of any third person regarding
00031  * infringement  or the like.  Any license provided herein, whether
00032  * implied or otherwise, applies only to this software file.  Patent
00033  * licenses, if any, provided herein do not apply to combinations of
00034  * this program with other software, or any other product whatsoever.
00035  *
00036  * You should have received a copy of the GNU General Public License
00037  * along with this program; if not, write the Free Software Foundation,
00038  * Inc., 59 Temple Place - Suite 330, Boston MA 02111-1307, USA.
00039  *
00040  * Contact information:  Silicon Graphics, Inc., 1600 Amphitheatre Pky,
00041  * Mountain View, CA 94043, or:
00042  *
00043  * http://www.sgi.com
00044  *
00045  * For further information regarding this notice, see:
00046  *
00047  * http://oss.sgi.com/projects/GenInfo/NoticeExplan
00048  *
00049  * ====================================================================
00050  * ====================================================================
00051  */
00052 
00053 static char *source_file = __FILE__;
00054 static char *rcs_id = "$Source: /home/bos/bk/kpro64-pending/be/opt/SCCS/s.opt_error.c $ $Revision: 1.5 $";
00055 
00056 #define _GNU_SOURCE
00057 #include <stdio.h>
00058 #include <string.h>
00059 #include <stdarg.h>
00060 
00061 #include "defs.h"
00062 #include "opt_defs.h"
00063 #include "opt_error.h"
00064 
00065 
00066 /*
00067  *   err_info is indexed by the error_number.   
00068  *   The first field of err_info also stores the error_number.
00069  *   we should assert the expression (err_info[i].errnum != i).
00070  */
00071 struct err_info {
00072   INT  errnum;
00073   char *str;
00074 };
00075 
00076 
00077 /*  
00078  *  The abort location is set when the error type is ER_FATAL.
00079  */
00080 char *opt_Abort_File = NULL;         /* name of the file that asserted */
00081 INT   opt_Abort_Loc  = 0;            /* line number that asserted */
00082 
00083 static INT   opt_num_errors;
00084 static BOOL  infoflag = TRUE;
00085 static BOOL  verbose  = TRUE;
00086 
00087 struct err_info err_str[MAX_ERN_NUMBER]= {
00088   {ERN_IGNORED,       0},
00089   {ERN_INTERNAL,      "Internal error"},
00090   {ERN_OUT_OF_MEM,    "Out of memory"},
00091   {ERN_BAD_OPTION,    "Unknown option: %s (ignored)."}
00092 };
00093 
00094 
00095 static void error_routine(unsigned doexit, const char *err_type, INT err_num, const char *fmt, va_list ap)
00096 {
00097   if (doexit && opt_Abort_File && opt_Abort_Loc)
00098     fprintf(stderr, "Abort at line %d of %s\n", opt_Abort_Loc, opt_Abort_File);
00099   
00100   if (err_type) {
00101     if (err_num > 0)
00102       fprintf (stderr, "%s %d: ", err_type, err_num);
00103     else
00104       fputs (err_type, stderr);
00105   }
00106   
00107   vfprintf(stderr, fmt, ap);
00108   
00109   if (fmt[strlen(fmt)-1] != '\n')
00110     fputc ('\n', stderr);
00111   fflush(stderr);
00112   
00113   if (doexit)
00114     exit(1);
00115 } /* error_routine */
00116 
00117 
00118 static void opt_fatal(INT errnum, va_list ap)
00119 {
00120   /* do NOT use OPT_ASSERT for (err_str[errnum].errnum != errnum) because
00121      OPT_ASSERT calls opt_fatal() eventually.  It might loop! */
00122   if ((err_str[errnum].errnum == errnum)
00123       || (err_str[errnum].errnum == ERN_IGNORED)) {
00124     error_routine(TRUE, "FATAL", errnum, err_str[errnum].str, ap);
00125   } else {
00126     error (TRUE, err_str[ERN_INTERNAL].errnum, "opt_fatal()");
00127   }
00128 }
00129 
00130 
00131 static void opt_error(INT errnum, va_list ap)
00132 {
00133   opt_num_errors++;
00134   OPT_ASSERT (err_str[errnum].errnum == errnum || err_str[errnum].errnum == ERN_IGNORED,
00135         "opt_error()");
00136   error_routine(FALSE, "ERROR", errnum, err_str[errnum].str, ap);
00137 }
00138 
00139 
00140 static void opt_verbose (INT errnum, va_list ap)
00141 {
00142   OPT_ASSERT (err_str[errnum].errnum == errnum || err_str[errnum].errnum == ERN_IGNORED,
00143         "opt_verbose()");
00144   error_routine(FALSE, 0, errnum, err_str[errnum].str, ap);
00145 }
00146 
00147 
00148 static void opt_info(INT errnum, va_list ap)
00149 {
00150   if (infoflag) {
00151     OPT_ASSERT (err_str[errnum].errnum == errnum || err_str[errnum].errnum == ERN_IGNORED,
00152     "opt_info()");
00153     error_routine(FALSE, "INFO", errnum, err_str[errnum].str, ap);
00154   }
00155 }
00156 
00157 
00158 void OPT_Error(INT type, INT errnum, ...)
00159 {
00160   va_list ap;
00161   
00162   va_start(ap, errnum);
00163   switch (type) {
00164   case ER_FATAL:
00165     opt_fatal(errnum, ap);
00166     break;
00167   case ER_INFO:
00168     opt_info(errnum, ap);
00169     break;
00170   case ER_ERROR:
00171     opt_error(errnum, ap);
00172     break;
00173   case ER_VERBOSE:
00174     opt_verbose (errnum, ap);
00175     break;
00176   }
00177   va_end (ap);
00178 }
00179 
00180 
00181 void OPT_Error_Fmt(INT type, const char *fmt_str, ...)
00182 {
00183   va_list ap;
00184   char *err_type_str;
00185   BOOL doexit;
00186   
00187   va_start(ap, fmt_str);
00188   switch (type) {
00189   case ER_FATAL:
00190     err_type_str = "FATAL";
00191     doexit = TRUE;
00192     break;
00193   case ER_INFO:
00194     err_type_str = "INFO";
00195     doexit = FALSE;
00196     break;
00197   case ER_ERROR:
00198     err_type_str = "ERROR";
00199     doexit = FALSE;
00200     break;
00201   case ER_VERBOSE:
00202     err_type_str = "VERBOSE";
00203     doexit = FALSE;
00204     break;
00205   }
00206   error_routine(doexit, err_type_str, ERN_IGNORED, fmt_str, ap);
00207   va_end(ap);
00208 }
00209 
00210 
00211 static void
00212 signal_cleanup(void)
00213 {
00214 }
00215 
00216 
00217 static void
00218 catch (int sig, int error_num)
00219 {
00220     switch (sig) {
00221         register string msg;
00222     case SIGBUS:
00223     case SIGSEGV:
00224         msg = error_num ? strerror(error_num) : strsignal(sig);
00225         fprintf (stderr, "%s: Signal: %s.\n", myname, msg);
00226         fflush (stderr);
00227         break;
00228     }
00229     signal (sig, SIG_IGN);
00230     signal_cleanup ();
00231     exit (1);
00232 } /* catch */
00233 
00234 
00235 void Opt_Catch_Signals (void)
00236 {
00237     if (signal(SIGHUP , SIG_IGN) != SIG_IGN) signal(SIGHUP , catch);
00238     if (signal(SIGINT , SIG_IGN) != SIG_IGN) signal(SIGINT , catch);
00239     if (signal(SIGQUIT, SIG_IGN) != SIG_IGN) signal(SIGQUIT, catch);
00240     if (signal(SIGILL , SIG_IGN) != SIG_IGN) signal(SIGILL , catch);
00241     if (signal(SIGTRAP, SIG_IGN) != SIG_IGN) signal(SIGTRAP, catch);
00242     if (signal(SIGIOT , SIG_IGN) != SIG_IGN) signal(SIGIOT , catch);
00243     if (signal(SIGEMT , SIG_IGN) != SIG_IGN) signal(SIGEMT , catch);
00244     if (signal(SIGFPE , SIG_IGN) != SIG_IGN) signal(SIGFPE , catch);
00245     if (signal(SIGBUS , SIG_IGN) != SIG_IGN) signal(SIGBUS , catch);
00246     if (signal(SIGSEGV, SIG_IGN) != SIG_IGN) signal(SIGSEGV, catch);
00247     if (signal(SIGTERM, SIG_IGN) != SIG_IGN) signal(SIGTERM, catch);
00248 } /* Opt_Catch_Signals */