iufError.h

Go to the documentation of this file.

#ifndef _IUFERROR_H
#define _IUFERROR_H

#ifdef __cplusplus
extern "C" {
#endif

#include <iuf.h>
#include <stdio.h>   // fprintf()
#include <stdlib.h>  // exit()


#ifdef __cplusplus
}
#endif

int iufErrorGetCount
(
    void
);

int iufErrorPrint
(
);

char * iufErrorString
(
);

int iufErrorPush
(
    const char *pFileName,          
    const char *pFunctionName,      
    int lineNumber,                 
    hid_t maj,                      
    hid_t min,                      
    char *msg                       
);


int iufErrorFormatAndPush
(
    const char *pFileName,          
    const char *pFunctionName,      
    int lineNumber,                 
    hid_t maj,                      
    hid_t min,                      
    char *msgFormat,                
    ...                             
);


int iufHDF5ErrorLog
(
    IUF_BOOL enable                 
);


int iufErrorLog
(
    IUF_BOOL enable                 
);


int iufErrorLogClear
(
    void
);


int iufErrorSetStream
(
    FILE *stream                    
);

int iufErrorSetStreamToFile
(
    const char * pFileName
);

int iufErrorCloseFileStream
(
);

int iufErrorAutoReportSet
(
    IUF_BOOL enable                 
);

IUF_BOOL iufErrorAutoReportGet
(
    void
);


extern hid_t  IUF_ERR_MAJ_GENERAL;  
extern hid_t  IUF_ERR_MAJ_MEMORY;   
extern hid_t  IUF_ERR_MAJ_VALUE;    
extern hid_t  IUF_ERR_MAJ_ERROR;    
extern hid_t  IUF_ERR_MAJ_HDF5;     

extern hid_t  IUF_ERR_MIN_ARG_VALUE;            
extern hid_t  IUF_ERR_MIN_ARG_FILENAME;         
extern hid_t  IUF_ERR_MIN_ALLOC;                
extern hid_t  IUF_ERR_MIN_MEMCOPY;              
extern hid_t  IUF_ERR_MIN_FORMAT;               
extern hid_t  IUF_ERR_MIN_ARG_NULL_VALUE;       
extern hid_t  IUF_ERR_MIN_ARG_DUPLICATE_KEY;    
extern hid_t  IUF_ERR_MIN_ARG_INVALID_KEY;      
extern hid_t  IUF_ERR_MIN_HDF5;                 
extern hid_t  IUF_ERR_MIN_ASSERT_FAILED;        



#define IUF_ERROR_PUSH(maj,min,msg)     iufErrorPush(__FILE__, __func__, __LINE__, maj, min, msg)

#define IUF_ERROR_PRINT(maj,min,msg)     iufErrorPush(__FILE__, __func__, __LINE__, maj, min, msg);\
                                            iufErrorPrint();

#define IUF_ERROR_FMT_PUSH(maj,min,fmt,...) iufErrorFormatAndPush(__FILE__, __func__, __LINE__, maj, min, fmt, __VA_ARGS__)



#define IUF_ERROR_FMT_PRINT(maj,min,fmt,...) iufErrorFormatAndPush(__FILE__, __func__, __LINE__, maj, min, fmt, __VA_ARGS__);\
                                            iufErrorPrint();


// Error handling convenience macro's

#define IUF_ERR_ALLOC_NULL_N_RETURN(var, adt,  retval) if ((var) == NULL) {                                 \
        IUF_ERROR_PUSH(IUF_ERR_MAJ_MEMORY, IUF_ERR_MIN_ALLOC, "calloc failed for " #adt);                   \
        return retval;                                                                                      \
    }


#define IUF_ERR_CHECK_NULL_N_RETURN(var, retval) if ((var) == NULL) {                                       \
        IUF_ERROR_PUSH(IUF_ERR_MAJ_VALUE, IUF_ERR_MIN_ARG_NULL_VALUE, "argument "  #var  " was NULL");      \
        return retval;                                                                                      \
    }

#define IUF_ERR_CHECK_EMPTYSTR_N_RETURN(var, return_value) if (strcmp((var),"") == 0) {                       \
        IUF_ERROR_PUSH(IUF_ERR_MAJ_VALUE, IUF_ERR_MIN_ARG_VALUE, "argument " #var  " was empty");           \
        return return_value;                                                                                \
    }


#define IUF_ERR_STRP_NULL_EMPTY(var, retval) IUF_ERR_CHECK_NULL_N_RETURN(var, retval);                      \
        IUF_ERR_CHECK_EMPTYSTR_N_RETURN(var, retval)


#define IUF_ERR_EVAL_N_RETURN(expr, retval) if (expr) {                                                     \
        IUF_ERROR_PUSH(IUF_ERR_MAJ_VALUE, IUF_ERR_MIN_ARG_VALUE, #expr "");                                 \
        return retval;                                                                                      \
    }


#define IUF_ERR_GENERAL      (100001)   
#define IUF_ERR_MEMORY       (100002)    
#define IUF_ERR_VALUE        (100003)    
#define IUF_UNUSED(x) (void)(x)

#define IUF_ASSERT( IN_CONDITION ) \
{ \
    if ( !(IN_CONDITION) )\
    { \
        IUF_ERROR_PUSH(IUF_ERR_MAJ_GENERAL,IUF_ERR_MIN_ASSERT_FAILED, "General error occurred, assertion failed for " #IN_CONDITION); \
        exit( IUF_ERR_GENERAL ); \
    } \
}

#define IUF_ASSERT_MEMORY( IN_CONDITION ) \
{ \
    if ( !(IN_CONDITION) )\
    { \
        IUF_ERROR_PUSH(IUF_ERR_MAJ_MEMORY,IUF_ERR_MIN_ASSERT_FAILED, "Memory error occurred, assertion failed for " #IN_CONDITION); \
        exit( IUF_ERR_MEMORY ); \
    } \
}

#define IUF_ASSERT_VALUE( IN_CONDITION ) \
{ \
    if ( !(IN_CONDITION) )\
    { \
        IUF_ERROR_PUSH(IUF_ERR_MAJ_VALUE,IUF_ERR_MIN_ASSERT_FAILED, "Value error occurred, assertion failed for " #IN_CONDITION); \
        exit( IUF_ERR_VALUE ); \
    } \
}


#endif  // _IUFERROR_H