Actual source code: error.c

  1: /*$Id: error.c,v 1.2 2001/04/10 19:37:38 bsmith Exp $*/
  2: /**********************************error.c*************************************
  3: SPARSE GATHER-SCATTER PACKAGE: bss_malloc bss_malloc ivec error comm gs queue

  5: Author: Henry M. Tufo III

  7: e-mail: hmt@cs.brown.edu

  9: snail-mail:
 10: Division of Applied Mathematics
 11: Brown University
 12: Providence, RI 02912

 14: Last Modification: 
 15: 6.21.97
 16: ***********************************error.c************************************/

 18: /**********************************error.c*************************************
 19: File Description:
 20: -----------------

 22: ***********************************error.c************************************/
 23: #include <stdio.h>
 24: #include <stdlib.h>
 25: #include <stdarg.h>

 27: #if   defined NXSRC
 28: #ifndef DELTA
 29: #include <nx.h>
 30: #endif

 32: #elif defined MPISRC
 33: #include <mpi.h>

 35: #endif

 37: #if   defined NXSRC
 38:  #include const.h
 39:  #include types.h
 40:  #include error.h
 41:  #include comm.h


 44: #elif defined MPISRC
 45: #include <mpi.h>
 46:  #include const.h
 47:  #include types.h
 48:  #include error.h
 49:  #include comm.h

 51: #else
 52:  #include const.h
 53:  #include error.h

 55: static int my_id=0;

 57: #endif


 60: void 
 61: error_msg_fatal_ (const char msg[])
 62: {
 63:   error_msg_fatal(msg);
 64: }



 68: /**********************************error.c*************************************
 69: Function error_msg_fatal()

 71: Input : pointer to formatted error message.
 72: Output: prints message to stdout.
 73: Return: na.
 74: Description: prints error message and terminates program.
 75: ***********************************error.c************************************/
 76: void 
 77: error_msg_fatal(const char msg[], ...)
 78: {
 79:   va_list    ap;
 80:   const char *p;
 81:   char       *sval, cval;
 82:   int        ival;
 83:   REAL       dval;


 86:   /* print error message along w/node identifier */
 87:   va_start(ap,msg);
 88:   printf("%d :: FATAL :: ", my_id);
 89:   for (p=msg; *p; p++)
 90:     {
 91:       if (*p != '%')
 92:         {
 93:           putchar(*p);
 94:           continue;
 95:         }
 96:       switch (*++p) {
 97:       case 'c':
 98:         cval = va_arg(ap,int);
 99:           putchar(cval);
100:         break;
101:       case 'd':
102:         ival = va_arg(ap,int);
103:         printf("%d",ival);
104:         break;
105:       case 'e':
106:         dval = va_arg(ap,REAL);
107:         printf("%e",dval);
108:         break;
109:       case 'f':
110:         dval = va_arg(ap,REAL);
111:         printf("%f",dval);
112:         break;
113:       case 'g':
114:         dval = va_arg(ap,REAL);
115:         printf("%g",dval);
116:         break;
117:       case 's':
118:         for (sval=va_arg(ap,char *); *sval; sval++)
119:           {putchar(*sval);}
120:         break;
121:       default:
122:         putchar(*p);
123:         break;
124:       }
125:     }
126:   /* printf("\n"); */
127:   va_end(ap);

129: #ifdef DELTA  
130:   fflush(stdout);
131: #else
132:   fflush(stdout);
133:   /*  fflush(NULL); */
134: #endif


137:   /* exit program */
138: #if   defined NXSRC
139:   abort();


142: #elif defined MPISRC
143:   /* Try with MPI_Finalize() as well _only_ if all procs call this routine */
144:   /* Choose a more meaningful error code than -12 */
145:   MPI_Abort(MPI_COMM_WORLD, -12);

147: #else
148:   exit(1);


151: #endif
152: }



156: /**********************************error.c*************************************
157: Function error_msg_warning()

159: Input : formatted string and arguments.
160: Output: conversion printed to stdout.
161: Return: na.
162: Description: prints error message.
163: ***********************************error.c************************************/
164: void 
165: error_msg_warning(const char msg[], ...)
166: {
167:   /* print error message along w/node identifier */
168: #if   defined V
169:   va_list ap;
170:   char *p, *sval, cval;
171:   int ival;
172:   REAL dval;

174:   va_start(ap,msg);
175:   if (!my_id)
176:     {
177:       printf("%d :: WARNING :: ", my_id);
178:       for (p=msg; *p; p++)
179:         {
180:           if (*p != '%')
181:             {
182:               putchar(*p);
183:               continue;
184:             }
185:           switch (*++p) {
186:           case 'c':
187:             cval = va_arg(ap,char);
188:             putchar(cval);
189:             break;
190:           case 'd':
191:             ival = va_arg(ap,int);
192:             printf("%d",ival);
193:             break;
194:           case 'e':
195:             dval = va_arg(ap,REAL);
196:             printf("%e",dval);
197:             break;
198:           case 'f':
199:             dval = va_arg(ap,REAL);
200:             printf("%f",dval);
201:             break;
202:           case 'g':
203:             dval = va_arg(ap,REAL);
204:             printf("%g",dval);
205:             break;
206:           case 's':
207:             for (sval=va_arg(ap,char *); *sval; sval++)
208:               {putchar(*sval);}
209:             break;
210:           default:
211:             putchar(*p);
212:             break;
213:           }
214:         }
215:       /*      printf("\n"); */
216:     }
217:   va_end(ap);


220: #elif defined VV
221:   va_list ap;
222:   char *p, *sval, cval;
223:   int ival;
224:   REAL dval;
225:   va_start(ap,msg);
226:   if (my_id>=0)
227:     {
228:       printf("%d :: WARNING :: ", my_id);
229:       for (p=msg; *p; p++)
230:         {
231:           if (*p != '%')
232:             {
233:               putchar(*p);
234:               continue;
235:             }
236:           switch (*++p) {
237:           case 'c':
238:             cval = va_arg(ap,char);
239:             putchar(cval);
240:             break;
241:           case 'd':
242:             ival = va_arg(ap,int);
243:             printf("%d",ival);
244:             break;
245:           case 'e':
246:             dval = va_arg(ap,REAL);
247:             printf("%e",dval);
248:             break;
249:           case 'f':
250:             dval = va_arg(ap,REAL);
251:             printf("%f",dval);
252:             break;
253:           case 'g':
254:             dval = va_arg(ap,REAL);
255:             printf("%g",dval);
256:             break;
257:           case 's':
258:             for (sval=va_arg(ap,char *); *sval; sval++)
259:               {putchar(*sval);}
260:             break;
261:           default:
262:             putchar(*p);
263:             break;
264:           }
265:         }
266:       /* printf("\n"); */
267:     }
268:   va_end(ap);
269: #endif

271: #ifdef DELTA  
272:   fflush(stdout);
273: #else
274:   fflush(stdout);
275:   /*  fflush(NULL); */
276: #endif

278: }