Actual source code: error.c

  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 petsc.h
 24: #include <stdio.h>
 25: #include <stdlib.h>
 26: #include <stdarg.h>

 28:  #include const.h
 29:  #include types.h
 30:  #include error.h
 31:  #include comm.h

 33: /**********************************error.c*************************************
 34: Function error_msg_fatal()

 36: Input : pointer to formatted error message.
 37: Output: prints message to stdout.
 38: Return: na.
 39: Description: prints error message and terminates program.
 40: ***********************************error.c************************************/
 41: void error_msg_fatal(const char msg[], ...)
 42: {
 43:   va_list    ap;
 44:   const char *p;
 45:   char       *sval, cval;
 46:   int        ival;
 47:   REAL       dval;


 50:   /* print error message along w/node identifier */
 51:   va_start(ap,msg);
 52:   printf("%d :: FATAL :: ", my_id);
 53:   for (p=msg; *p; p++)
 54:     {
 55:       if (*p != '%')
 56:         {
 57:           putchar(*p);
 58:           continue;
 59:         }
 60:       switch (*++p) {
 61:       case 'c':
 62:         cval = va_arg(ap,int);
 63:           putchar(cval);
 64:         break;
 65:       case 'd':
 66:         ival = va_arg(ap,int);
 67:         printf("%d",ival);
 68:         break;
 69:       case 'e':
 70:         dval = va_arg(ap,REAL);
 71:         printf("%e",dval);
 72:         break;
 73:       case 'f':
 74:         dval = va_arg(ap,REAL);
 75:         printf("%f",dval);
 76:         break;
 77:       case 'g':
 78:         dval = va_arg(ap,REAL);
 79:         printf("%g",dval);
 80:         break;
 81:       case 's':
 82:         for (sval=va_arg(ap,char *); *sval; sval++)
 83:           {putchar(*sval);}
 84:         break;
 85:       default:
 86:         putchar(*p);
 87:         break;
 88:       }
 89:     }
 90:   /* printf("\n"); */
 91:   va_end(ap);

 93: #ifdef DELTA  
 94:   fflush(stdout);
 95: #else
 96:   fflush(stdout);
 97:   /*  fflush(NULL); */
 98: #endif


101:   /* Try with MPI_Finalize() as well _only_ if all procs call this routine */
102:   /* Choose a more meaningful error code than -12 */
103:   MPI_Abort(MPI_COMM_WORLD, -12);
104: }



108: /**********************************error.c*************************************
109: Function error_msg_warning()

111: Input : formatted string and arguments.
112: Output: conversion printed to stdout.
113: Return: na.
114: Description: prints error message.
115: ***********************************error.c************************************/
116: void 
117: error_msg_warning(const char msg[], ...)
118: {
119:   /* print error message along w/node identifier */
120: #if   defined V
121:   va_list ap;
122:   char *p, *sval, cval;
123:   int ival;
124:   REAL dval;

126:   va_start(ap,msg);
127:   if (!my_id)
128:     {
129:       printf("%d :: WARNING :: ", my_id);
130:       for (p=msg; *p; p++)
131:         {
132:           if (*p != '%')
133:             {
134:               putchar(*p);
135:               continue;
136:             }
137:           switch (*++p) {
138:           case 'c':
139:             cval = va_arg(ap,char);
140:             putchar(cval);
141:             break;
142:           case 'd':
143:             ival = va_arg(ap,int);
144:             printf("%d",ival);
145:             break;
146:           case 'e':
147:             dval = va_arg(ap,REAL);
148:             printf("%e",dval);
149:             break;
150:           case 'f':
151:             dval = va_arg(ap,REAL);
152:             printf("%f",dval);
153:             break;
154:           case 'g':
155:             dval = va_arg(ap,REAL);
156:             printf("%g",dval);
157:             break;
158:           case 's':
159:             for (sval=va_arg(ap,char *); *sval; sval++)
160:               {putchar(*sval);}
161:             break;
162:           default:
163:             putchar(*p);
164:             break;
165:           }
166:         }
167:       /*      printf("\n"); */
168:     }
169:   va_end(ap);


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

223: #ifdef DELTA  
224:   fflush(stdout);
225: #else
226:   fflush(stdout);
227:   /*  fflush(NULL); */
228: #endif

230: }