Actual source code: petscerror.h
1: /*
2: Contains all error handling interfaces for PETSc.
3: */
6: #include petsc.h
9: /*
10: Defines the directory where the compiled source is located; used
11: in printing error messages. Each makefile has an entry
12: LOCDIR = thedirectory
13: and bmake/common_variables includes in CCPPFLAGS -D__SDIR__='"${LOCDIR}"'
14: which is a flag passed to the C/C++ compilers. This declaration below
15: is only needed if some code is compiled without the -D__SDIR__
16: */
19: #endif
21: /*
22: Defines the function where the compiled source is located; used
23: in printing error messages. This is defined here in case the user
24: does not declare it.
25: */
28: #endif
30: /*
31: These are the generic error codes. These error codes are used
32: many different places in the PETSc source code. The string versions are
33: at src/sys/error/err.c any changes here must also be made there
34: These are also define in include/finclude/petscerror.h any CHANGES here
35: must be also made there.
37: */
38: #define PETSC_ERR_MIN_VALUE 54 /* should always be one less then the smallest value */
40: #define PETSC_ERR_MEM 55 /* unable to allocate requested memory */
41: #define PETSC_ERR_SUP 56 /* no support for requested operation */
42: #define PETSC_ERR_SUP_SYS 57 /* no support for requested operation on this computer system */
43: #define PETSC_ERR_ORDER 58 /* operation done in wrong order */
44: #define PETSC_ERR_SIG 59 /* signal received */
45: #define PETSC_ERR_FP 72 /* floating point exception */
46: #define PETSC_ERR_COR 74 /* corrupted PETSc object */
47: #define PETSC_ERR_LIB 76 /* error in library called by PETSc */
48: #define PETSC_ERR_PLIB 77 /* PETSc library generated inconsistent data */
49: #define PETSC_ERR_MEMC 78 /* memory corruption */
50: #define PETSC_ERR_CONV_FAILED 82 /* iterative method (KSP or SNES) failed */
51: #define PETSC_ERR_USER 83 /* user has not provided needed function */
52: #define PETSC_ERR_SYS 88 /* error in system call */
54: #define PETSC_ERR_ARG_SIZ 60 /* nonconforming object sizes used in operation */
55: #define PETSC_ERR_ARG_IDN 61 /* two arguments not allowed to be the same */
56: #define PETSC_ERR_ARG_WRONG 62 /* wrong argument (but object probably ok) */
57: #define PETSC_ERR_ARG_CORRUPT 64 /* null or corrupted PETSc object as argument */
58: #define PETSC_ERR_ARG_OUTOFRANGE 63 /* input argument, out of range */
59: #define PETSC_ERR_ARG_BADPTR 68 /* invalid pointer argument */
60: #define PETSC_ERR_ARG_NOTSAMETYPE 69 /* two args must be same object type */
61: #define PETSC_ERR_ARG_NOTSAMECOMM 80 /* two args must be same communicators */
62: #define PETSC_ERR_ARG_WRONGSTATE 73 /* object in argument is in wrong state, e.g. unassembled mat */
63: #define PETSC_ERR_ARG_INCOMP 75 /* two arguments are incompatible */
64: #define PETSC_ERR_ARG_NULL 85 /* argument is null that should not be */
65: #define PETSC_ERR_ARG_UNKNOWN_TYPE 86 /* type name doesn't match any registered type */
66: #define PETSC_ERR_ARG_DOMAIN 87 /* argument is not in domain of function */
68: #define PETSC_ERR_FILE_OPEN 65 /* unable to open file */
69: #define PETSC_ERR_FILE_READ 66 /* unable to read from file */
70: #define PETSC_ERR_FILE_WRITE 67 /* unable to write to file */
71: #define PETSC_ERR_FILE_UNEXPECTED 79 /* unexpected data in file */
73: #define PETSC_ERR_MAT_LU_ZRPVT 71 /* detected a zero pivot during LU factorization */
74: #define PETSC_ERR_MAT_CH_ZRPVT 81 /* detected a zero pivot during Cholesky factorization */
76: #define PETSC_ERR_MAX_VALUE 89 /* this is always the one more than the largest error code */
78: #if defined(PETSC_USE_ERRORCHECKING)
80: /*MC
81: SETERRQ - Macro that is called when an error has been detected,
83: Not Collective
85: Synopsis:
86: PetscErrorCode SETERRQ(PetscErrorCode errorcode,char *message)
89: Input Parameters:
90: + errorcode - nonzero error code, see the list of standard error codes in include/petscerror.h
91: - message - error message
93: Level: beginner
95: Notes:
96: Once the error handler is called the calling function is then returned from with the given error code.
98: See SETERRQ1(), SETERRQ2(), SETERRQ3() for versions that take arguments
100: In Fortran MPI_Abort() is always called
102: Experienced users can set the error handler with PetscPushErrorHandler().
104: Concepts: error^setting condition
106: .seealso: PetscTraceBackErrorHandler(), PetscPushErrorHandler(), PetscError(), CHKERRQ(), CHKMEMQ, SETERRQ1(), SETERRQ2(), SETERRQ3()
107: M*/
108: #define SETERRQ(n,s) {return PetscError(__LINE__,__FUNCT__,__FILE__,__SDIR__,n,1,s);}
110: /*MC
111: SETERRQ1 - Macro that is called when an error has been detected,
113: Not Collective
115: Synopsis:
116: PetscErrorCode SETERRQ1(PetscErrorCode errorcode,char *formatmessage,arg)
119: Input Parameters:
120: + errorcode - nonzero error code, see the list of standard error codes in include/petscerror.h
121: . message - error message in the printf format
122: - arg - argument (for example an integer, string or double)
124: Level: beginner
126: Notes:
127: Once the error handler is called the calling function is then returned from with the given error code.
129: Experienced users can set the error handler with PetscPushErrorHandler().
131: Concepts: error^setting condition
133: .seealso: PetscTraceBackErrorHandler(), PetscPushErrorHandler(), PetscError(), CHKERRQ(), CHKMEMQ, SETERRQ(), SETERRQ2(), SETERRQ3()
134: M*/
135: #define SETERRQ1(n,s,a1) {return PetscError(__LINE__,__FUNCT__,__FILE__,__SDIR__,n,1,s,a1);}
137: /*MC
138: SETERRQ2 - Macro that is called when an error has been detected,
140: Not Collective
142: Synopsis:
143: PetscErrorCode SETERRQ2(PetscErrorCode errorcode,char *formatmessage,arg1,arg2)
146: Input Parameters:
147: + errorcode - nonzero error code, see the list of standard error codes in include/petscerror.h
148: . message - error message in the printf format
149: . arg1 - argument (for example an integer, string or double)
150: - arg2 - argument (for example an integer, string or double)
152: Level: beginner
154: Notes:
155: Once the error handler is called the calling function is then returned from with the given error code.
157: Experienced users can set the error handler with PetscPushErrorHandler().
159: Concepts: error^setting condition
161: .seealso: PetscTraceBackErrorHandler(), PetscPushErrorHandler(), PetscError(), CHKERRQ(), CHKMEMQ, SETERRQ1(), SETERRQ3()
162: M*/
163: #define SETERRQ2(n,s,a1,a2) {return PetscError(__LINE__,__FUNCT__,__FILE__,__SDIR__,n,1,s,a1,a2);}
165: /*MC
166: SETERRQ3 - Macro that is called when an error has been detected,
168: Not Collective
170: Synopsis:
171: PetscErrorCode SETERRQ3(PetscErrorCode errorcode,char *formatmessage,arg1,arg2,arg3)
174: Input Parameters:
175: + errorcode - nonzero error code, see the list of standard error codes in include/petscerror.h
176: . message - error message in the printf format
177: . arg1 - argument (for example an integer, string or double)
178: . arg2 - argument (for example an integer, string or double)
179: - arg3 - argument (for example an integer, string or double)
181: Level: beginner
183: Notes:
184: Once the error handler is called the calling function is then returned from with the given error code.
186: There are also versions for 4, 5, 6 and 7 arguments.
188: Experienced users can set the error handler with PetscPushErrorHandler().
190: Concepts: error^setting condition
192: .seealso: PetscTraceBackErrorHandler(), PetscPushErrorHandler(), PetscError(), CHKERRQ(), CHKMEMQ, SETERRQ1(), SETERRQ2()
193: M*/
194: #define SETERRQ3(n,s,a1,a2,a3) {return PetscError(__LINE__,__FUNCT__,__FILE__,__SDIR__,n,1,s,a1,a2,a3);}
196: #define SETERRQ4(n,s,a1,a2,a3,a4) {return PetscError(__LINE__,__FUNCT__,__FILE__,__SDIR__,n,1,s,a1,a2,a3,a4);}
197: #define SETERRQ5(n,s,a1,a2,a3,a4,a5) {return PetscError(__LINE__,__FUNCT__,__FILE__,__SDIR__,n,1,s,a1,a2,a3,a4,a5);}
198: #define SETERRQ6(n,s,a1,a2,a3,a4,a5,a6) {return PetscError(__LINE__,__FUNCT__,__FILE__,__SDIR__,n,1,s,a1,a2,a3,a4,a5,a6);}
199: #define SETERRQ7(n,s,a1,a2,a3,a4,a5,a6,a7) {return PetscError(__LINE__,__FUNCT__,__FILE__,__SDIR__,n,1,s,a1,a2,a3,a4,a5,a6,a7);}
200: #define SETERRABORT(comm,n,s) {PetscError(__LINE__,__FUNCT__,__FILE__,__SDIR__,n,1,s);MPI_Abort(comm,n);}
202: /*MC
203: CHKERRQ - Checks error code, if non-zero it calls the error handler and then returns
205: Not Collective
207: Synopsis:
208: PetscErrorCode CHKERRQ(PetscErrorCode errorcode)
211: Input Parameters:
212: . errorcode - nonzero error code, see the list of standard error codes in include/petscerror.h
214: Level: beginner
216: Notes:
217: Once the error handler is called the calling function is then returned from with the given error code.
219: Experienced users can set the error handler with PetscPushErrorHandler().
221: CHKERRQ(n) is fundamentally a macro replacement for
222: if (n) return(PetscError(...,n,...));
224: Although typical usage resembles "void CHKERRQ(PetscErrorCode)" as described above, for certain uses it is
225: highly inappropriate to use it in this manner as it invokes return(PetscErrorCode). In particular,
226: it cannot be used in functions which return(void) or any other datatype. In these types of functions,
227: you can use CHKERRV() which returns without an error code (bad idea since the error is ignored or
228: if (n) {PetscError(....); return(YourReturnType);}
229: where you may pass back a PETSC_NULL to indicate an error. You can also call CHKERRABORT(comm,n) to have
230: MPI_Abort() returned immediately.
232: In Fortran MPI_Abort() is always called
234: Concepts: error^setting condition
236: .seealso: PetscTraceBackErrorHandler(), PetscPushErrorHandler(), PetscError(), SETERRQ(), CHKMEMQ, SETERRQ1(), SETERRQ2(), SETERRQ2()
237: M*/
238: #define CHKERRQ(n) if (n) {return PetscError(__LINE__,__FUNCT__,__FILE__,__SDIR__,n,0," ");}
240: #define CHKERRV(n) if (n) {n = PetscError(__LINE__,__FUNCT__,__FILE__,__SDIR__,n,0," ");return;}
241: #define CHKERRABORT(comm,n) if (n) {PetscError(__LINE__,__FUNCT__,__FILE__,__SDIR__,n,0," ");MPI_Abort(comm,n);}
242: #define CHKERRCONTINUE(n) if (n) {PetscError(__LINE__,__FUNCT__,__FILE__,__SDIR__,n,0," ");}
244: #define CHKFPQ(f) if (f != f) {SETERRQ(PETSC_ERR_FP, "Invalid value: NaN");}
246: #ifdef PETSC_CLANGUAGE_CXX
248: #define CHKERRXX(n) if (n) {PetscErrorCxx(__LINE__,__FUNCT__,__FILE__,__SDIR__,n,0);}
250: #endif
252: /*MC
253: CHKMEMQ - Checks the memory for corruption, calls error handler if any is detected
255: Not Collective
257: Synopsis:
258: CHKMEMQ;
260: Level: beginner
262: Notes:
263: Must run with the option -malloc_debug to enable this option
265: Once the error handler is called the calling function is then returned from with the given error code.
267: By defaults prints location where memory that is corrupted was allocated.
269: Use CHKMEMA for functions that return void
271: Concepts: memory corruption
273: .seealso: PetscTraceBackErrorHandler(), PetscPushErrorHandler(), PetscError(), SETERRQ(), CHKMEMQ, SETERRQ1(), SETERRQ2(), SETERRQ3(),
274: PetscMallocValidate()
275: M*/
276: #define CHKMEMQ {PetscErrorCode _7_PetscMallocValidate(__LINE__,__FUNCT__,__FILE__,__SDIR__);CHKERRQ(_7_ierr);}
278: #define CHKMEMA {PetscMallocValidate(__LINE__,__FUNCT__,__FILE__,__SDIR__);}
280: #if defined(PETSC_UNDERSCORE_CHKERR)
282: #define _ __g
284: #endif
286: #define PETSC_EXCEPTIONS_MAX 256
292: EXTERN PetscErrorCode PetscExceptionPush(PetscErrorCode);
293: EXTERN PetscErrorCode PetscExceptionPop(PetscErrorCode);
295: EXTERN PetscErrorCode PetscErrorSetCatchable(PetscErrorCode,PetscTruth);
296: EXTERN PetscTruth PetscErrorIsCatchable(PetscErrorCode);
297: /*MC
298: PetscExceptionCaught - Indicates if a specific exception zierr was caught.
300: Not Collective
302: Synopsis:
303: PetscTruth PetscExceptionCaught(PetscErrorCode xierr,PetscErrorCode zierr);
305: Input Parameters:
306: + xierr - error code returned from PetscExceptionTry1() or other PETSc routine
307: - zierr - error code you want it to be
309: Level: advanced
311: Notes:
312: PETSc must not be configured using the option --with-errorchecking=0 for this to work
314: Use PetscExceptionValue() to see if an error code is being "tried"
316: Concepts: exceptions, exception handling
318: .seealso: PetscTraceBackErrorHandler(), PetscPushErrorHandler(), PetscError(), SETERRQ(), CHKMEMQ, SETERRQ1(), SETERRQ2(), SETERRQ3(),
319: CHKERRQ(), PetscExceptionTry1(), PetscExceptionValue()
320: M*/
321: PETSC_STATIC_INLINE PetscTruth PetscExceptionCaught(PetscErrorCode xierr,PetscErrorCode zierr) {
322: PetscInt i;
323: if (xierr != zierr) return PETSC_FALSE;
324: for (i=0; i<PetscErrorUncatchableCount; i++) {
325: if (PetscErrorUncatchable[i] == zierr) {
326: return PETSC_FALSE;
327: }
328: }
329: return PETSC_TRUE;
330: }
332: /*MC
333: PetscExceptionValue - Indicates if the error code is one that is currently being tried
335: Not Collective
337: Synopsis:
338: PetscTruth PetscExceptionValue(PetscErrorCode xierr);
340: Input Parameters:
341: . xierr - error code
343: Level: developer
345: Notes:
346: PETSc must not be configured using the option --with-errorchecking=0 for this to work
348: Use PetscExceptionCaught() to see if the current error code is EXACTLY the one you want
350: Concepts: exceptions, exception hanlding
352: .seealso: PetscTraceBackErrorHandler(), PetscPushErrorHandler(), PetscError(), SETERRQ(), CHKMEMQ, SETERRQ1(), SETERRQ2(), SETERRQ3(),
353: CHKERRQ(), PetscExceptionTry1(), PetscExceptionCaught()
354: M*/
355: PETSC_STATIC_INLINE PetscTruth PetscExceptionValue(PetscErrorCode zierr) {
356: PetscInt i;
357: for (i=0; i<PetscExceptionsCount; i++) {
358: if (PetscExceptions[i] == zierr) {
359: return PETSC_TRUE;
360: }
361: }
362: return PETSC_FALSE;
363: }
365: /*MC
366: PetscExceptionTry1 - Runs the routine, causing a particular error code to be treated as an exception,
367: rather than an error. That is if that error code is treated the program returns to this level,
368: but does not call the error handlers
370: Not Collective
372: Synopsis:
373: PetscErrorCode PetscExceptionTry1(PetscErrorCode routine(....),PetscErrorCode);
375: Level: advanced
377: No Fortran Equivalent (see PetscExceptionPush() for Fortran)
379: Notes:
380: PETSc must not be configured using the option --with-errorchecking=0 for this to work
382: Note: In general, the outer most try on an exception is the one that will be caught (that is trys down in
383: PETSc code will not usually handle an exception that was issued above). See SNESSolve() for an example
384: of how the local try is ignored if a higher (in the stack) one is also in effect.
386: Concepts: exceptions, exception hanlding
388: .seealso: PetscTraceBackErrorHandler(), PetscPushErrorHandler(), PetscError(), SETERRQ(), CHKMEMQ, SETERRQ1(), SETERRQ2(), SETERRQ3(),
389: CHKERRQ(), PetscExceptionCaught(), PetscExceptionPush(), PetscExceptionPop()
390: M*/
392: #define PetscExceptionTry1(a,b) (PetscExceptionTmp1 = PetscExceptionPush(b)) ? PetscExceptionTmp1 : (PetscExceptionTmp1 = a, (PetscExceptionTmp = PetscExceptionPop(b)) ? PetscExceptionTmp : PetscExceptionTmp1)
394: /*
395: Used by PetscExceptionTrySync(). Returns zierr on ALL processes in comm iff xierr is zierr on at least one process and zero on all others.
396: */
397: PETSC_STATIC_INLINE PetscErrorCode PetscExceptionTrySync_Private(MPI_Comm comm,PetscErrorCode xierr,PetscErrorCode zierr)
398: {
399: PetscReal in[2],out[2];
402: if (xierr != zierr) return xierr;
404: in[0] = xierr;
405: in[1] = 0.0; /* dummy value */
407: MPI_Allreduce(in,out,2,MPIU_REAL,0,comm); if (ierr) {;}
408: return xierr;
409: }
411: /*MC
412: PetscExceptionTrySyncNorm - Runs the routine, causing a particular error code to be treated as an exception,
413: rather than an error. That is if that error code is treated the program returns to this level,
414: but does not call the error handlers
416: Collective on Comm
418: Synopsis:
419: PetscExceptionTrySyncNorm(MPI_Comm comm,PetscErrorCode routine(....),PetscErrorCode);
421: Level: advanced
423: Notes: This synchronizes the error code across all processes in the communicator IF the code matches PetscErrorCode. The next
424: call with an MPI_Reduce()/MPI_Allreduce() MUST be VecNorm() [We can added VecDot() and maybe others as needed].
426: PETSc must not be configured using the option --with-errorchecking=0 for this to work
428: Note: In general, the outer most try on an exception is the one that will be caught (that is trys down in
429: PETSc code will not usually handle an exception that was issued above). See SNESSolve() for an example
430: of how the local try is ignored if a higher (in the stack) one is also in effect.
432: Concepts: exceptions, exception hanlding
434: .seealso: PetscTraceBackErrorHandler(), PetscPushErrorHandler(), PetscError(), SETERRQ(), CHKMEMQ, SETERRQ1(), SETERRQ2(), SETERRQ3(),
435: CHKERRQ(), PetscExceptionCaught(), PetscExceptionPush(), PetscExceptionPop(), PetscExceptionTry1()
436: M*/
438: #define PetscExceptionTrySyncNorm(comm,a,b) (PetscExceptionTmp = PetscExceptionPush(b)) ? PetscExceptionTmp : \
439: (PetscExceptionTmp = a , PetscExceptionPop(b),PetscExceptionTrySyncNorm_Private(comm,PetscExceptionTmp,b))
441: #else
443: /*
444: These are defined to be empty for when error checking is turned off, with config/configure.py --with-errorchecking=0
445: */
447: #define SETERRQ(n,s) ;
448: #define SETERRQ1(n,s,a1) ;
449: #define SETERRQ2(n,s,a1,a2) ;
450: #define SETERRQ3(n,s,a1,a2,a3) ;
451: #define SETERRQ4(n,s,a1,a2,a3,a4) ;
452: #define SETERRQ5(n,s,a1,a2,a3,a4,a5) ;
453: #define SETERRQ6(n,s,a1,a2,a3,a4,a5,a6) ;
454: #define SETERRABORT(comm,n,s) ;
456: #define CHKERRQ(n) ;
457: #define CHKERRABORT(comm,n) ;
458: #define CHKERRCONTINUE(n) ;
459: #define CHKFPQ(f) ;
460: #define CHKMEMQ ;
462: #if !defined(PETSC_SKIP_UNDERSCORE_CHKERR)
463: #define _
465: #endif
467: #define PetscExceptionPush(a) 0
468: #define PetscExceptionPop(a) 0
469: #define PetscErrorSetCatchable(a,b) 0
470: #define PetscErrorIsCatchable(a) PETSC_FALSE
472: #define PetscExceptionCaught(a,b) PETSC_FALSE
473: #define PetscExceptionValue(a) PETSC_FALSE
474: #define PetscExceptionTry1(a,b) a
475: #define PetscExceptionTrySyncNorm(comm,a,b) a
477: #endif
479: EXTERN PetscErrorCode PetscErrorPrintfInitialize(void);
480: EXTERN PetscErrorCode PetscErrorMessage(int,const char*[],char **);
481: EXTERN PetscErrorCode PetscTraceBackErrorHandler(int,const char*,const char*,const char*,PetscErrorCode,int,const char*,void*);
482: #ifdef PETSC_CLANGUAGE_CXX
483: #include <sstream>
484: EXTERN void PetscTraceBackErrorHandlerCxx(int,const char *,const char *,const char *,PetscErrorCode,int, std::ostringstream&);
485: #endif
486: EXTERN PetscErrorCode PetscIgnoreErrorHandler(int,const char*,const char*,const char*,PetscErrorCode,int,const char*,void*);
487: EXTERN PetscErrorCode PetscEmacsClientErrorHandler(int,const char*,const char*,const char*,PetscErrorCode,int,const char*,void*);
488: EXTERN PetscErrorCode PetscMPIAbortErrorHandler(int,const char*,const char*,const char*,PetscErrorCode,int,const char*,void*);
489: EXTERN PetscErrorCode PetscAbortErrorHandler(int,const char*,const char*,const char*,PetscErrorCode,int,const char*,void*);
490: EXTERN PetscErrorCode PetscAttachDebuggerErrorHandler(int,const char*,const char*,const char*,PetscErrorCode,int,const char*,void*);
491: EXTERN PetscErrorCode PetscReturnErrorHandler(int,const char*,const char*,const char*,PetscErrorCode,int,const char*,void*);
492: EXTERN PetscErrorCode PetscError(int,const char*,const char*,const char*,PetscErrorCode,int,const char*,...) PETSC_PRINTF_FORMAT_CHECK(7,8);
493: EXTERN void PetscErrorCxx(int,const char*,const char*,const char*,PetscErrorCode,int);
494: EXTERN PetscErrorCode PetscPushErrorHandler(PetscErrorCode (*handler)(int,const char*,const char*,const char*,PetscErrorCode,int,const char*,void*),void*);
495: EXTERN PetscErrorCode PetscPopErrorHandler(void);
496: EXTERN PetscErrorCode PetscDefaultSignalHandler(int,void*);
497: EXTERN PetscErrorCode PetscPushSignalHandler(PetscErrorCode (*)(int,void *),void*);
498: EXTERN PetscErrorCode PetscPopSignalHandler(void);
500: typedef enum {PETSC_FP_TRAP_OFF=0,PETSC_FP_TRAP_ON=1} PetscFPTrap;
501: EXTERN PetscErrorCode PetscSetFPTrap(PetscFPTrap);
503: /*
504: Allows the code to build a stack frame as it runs
505: */
506: #if defined(PETSC_USE_DEBUG)
508: #define PETSCSTACKSIZE 15
510: typedef struct {
511: const char *function[PETSCSTACKSIZE];
512: const char *file[PETSCSTACKSIZE];
513: const char *directory[PETSCSTACKSIZE];
514: int line[PETSCSTACKSIZE];
515: int currentsize;
516: } PetscStack;
519: EXTERN PetscErrorCode PetscStackCopy(PetscStack*,PetscStack*);
520: EXTERN PetscErrorCode PetscStackPrint(PetscStack*,FILE* fp);
522: #define PetscStackActive (petscstack != 0)
525: /*MC
527: used for error handling.
529: Synopsis:
532: Usage:
533: .vb
534: int something;
537: .ve
539: Notes:
540: Not available in Fortran
542: Level: developer
544: .seealso: PetscFunctionReturn()
546: .keywords: traceback, error handling
547: M*/
549: {\
550: if (petscstack && (petscstack->currentsize < PETSCSTACKSIZE)) { \
551: petscstack->function[petscstack->currentsize] = __FUNCT__; \
552: petscstack->file[petscstack->currentsize] = __FILE__; \
553: petscstack->directory[petscstack->currentsize] = __SDIR__; \
554: petscstack->line[petscstack->currentsize] = __LINE__; \
555: petscstack->currentsize++; \
556: }}
558: #define PetscStackPush(n) \
559: {if (petscstack && (petscstack->currentsize < PETSCSTACKSIZE)) { \
560: petscstack->function[petscstack->currentsize] = n; \
561: petscstack->file[petscstack->currentsize] = "unknown"; \
562: petscstack->directory[petscstack->currentsize] = "unknown"; \
563: petscstack->line[petscstack->currentsize] = 0; \
564: petscstack->currentsize++; \
565: }}
567: #define PetscStackPop \
568: {if (petscstack && petscstack->currentsize > 0) { \
569: petscstack->currentsize--; \
570: petscstack->function[petscstack->currentsize] = 0; \
571: petscstack->file[petscstack->currentsize] = 0; \
572: petscstack->directory[petscstack->currentsize] = 0; \
573: petscstack->line[petscstack->currentsize] = 0; \
574: }};
576: /*MC
577: PetscFunctionReturn - Last executable line of each PETSc function
578: used for error handling. Replaces return()
580: Synopsis:
581: void return(0);
583: Usage:
584: .vb
585: ....
586: return(0);
587: }
588: .ve
590: Notes:
591: Not available in Fortran
593: Level: developer
597: .keywords: traceback, error handling
598: M*/
599: #define PetscFunctionReturn(a) \
600: {\
601: PetscStackPop; \
602: return(a);}
604: #define PetscFunctionReturnVoid() \
605: {\
606: PetscStackPop; \
607: return;}
610: #else
613: #define PetscFunctionReturn(a) return(a)
614: #define PetscFunctionReturnVoid() return
615: #define PetscStackPop
616: #define PetscStackPush(f)
617: #define PetscStackActive 0
619: #endif
621: EXTERN PetscErrorCode PetscStackCreate(void);
622: EXTERN PetscErrorCode PetscStackView(PetscViewer);
623: EXTERN PetscErrorCode PetscStackDestroy(void);
624: EXTERN PetscErrorCode PetscStackPublish(void);
625: EXTERN PetscErrorCode PetscStackDepublish(void);
629: #endif