clipm_priv_error.h

Go to the documentation of this file.

/*********************************************************************
 * E.S.O. - VLT project
 *
 * "@(#) $Id: clipm_priv_error.h 279867 2016-03-10 10:39:31Z cgarcia $"
 *
 * PRIVATE functions for clipm internal error handling, requires CPL 4.0
 *
 * who       when        what
 * --------  ----------  ----------------------------------------------
 * hlorch    2006-05-11  created
 */

#ifndef CLIPM_PRIV_ERROR_H
#define CLIPM_PRIV_ERROR_H

/*-----------------------------------------------------------------------------
    Includes
 -----------------------------------------------------------------------------*/

#include <cpl.h>

#include <string.h>

/*-----------------------------------------------------------------------------
    Functional Macros
 -----------------------------------------------------------------------------*/

#define _CLIPM_ERROR_SET_WHERE_() \
do { \
    if (CLIPM_ERROR_IS_SET()) \
    { \
        const char      *_msg; \
        int             _n = 0; \
        \
        _msg = cpl_error_get_message(); \
        /* search the beginning of the last custom message */ \
        while (_msg[_n] != '\0' && _msg[_n] != ':') \
            _n++; \
        while (_msg[_n] == ':' || _msg[_n] == ' ') \
            _n++; \
        cpl_error_set_message(              __func__, \
                                            cpl_error_get_code(), \
                                            "%s", _msg+_n); \
        clipm_error_is_set_where = 1; \
    } \
} while (0)

#define _CLIPM_ERROR_SET_MSG_(code, object, msg) \
do { \
    char _clipm_error_msg[256]; \
    _clipm_priv_error_sprint_messages(      _clipm_error_msg, \
                                            object, \
                                            msg, \
                                            255); \
    cpl_error_set_message(                  __func__, \
                                            code, \
                                            "%s", _clipm_error_msg); \
    clipm_error_is_set_where = 1; \
} while (0)

/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
#define CLIPM_TRY \
    int             clipm_error_catch_call_flag, \
                    clipm_error_is_set_where = 0; \
    cpl_errorstate  clipm_error_trystate; \
    \
    clipm_error_trystate = cpl_errorstate_get(); \
    \
    do

/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
#define CLIPM_CATCH \
    while (0); \
    \
    goto _CLIPM_CATCH_LABEL_; /* avoid warning if not used */ \
    _CLIPM_CATCH_LABEL_: \
    \
    if ((clipm_error_catch_call_flag = (CLIPM_ERROR_IS_SET()))) \
    { \
        if (!clipm_error_is_set_where) \
            _CLIPM_ERROR_SET_WHERE_(); \
    } \
    \
    if (clipm_error_catch_call_flag)

/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
#define CLIPM_ERROR_GET_NEW_SINCE_TRY(void) \
    (CLIPM_ERROR_IS_NONE() ? CPL_ERROR_NONE : cpl_error_get_code())

/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
#define CLIPM_ERROR_RECOVER_TRYSTATE(void) \
do { \
    cpl_errorstate_set(clipm_error_trystate); \
    clipm_error_is_set_where = 0; \
} while (0)

/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
#define CLIPM_ERROR_SET(code) \
do { \
    CLIPM_TRY_ASSERT(code != CPL_ERROR_NONE); \
    cpl_error_set(__func__, code); \
    clipm_error_is_set_where = 1; \
} while (0)

/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
#define CLIPM_ERROR_SET_MSG(code, object, msg) \
do { \
    CLIPM_TRY_ASSERT(code != CPL_ERROR_NONE); \
    _CLIPM_ERROR_SET_MSG_(code, object, msg); \
} while (0)

/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
#define CLIPM_ERROR_SET_MSG_IF_CODE(code, object, msg) \
do { \
    CLIPM_TRY_ASSERT(code != CPL_ERROR_NONE); \
    if (CLIPM_ERROR_GET_NEW_SINCE_TRY() == code) \
        _CLIPM_ERROR_SET_MSG_(code, object, msg); \
} while (0)

/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
#define CLIPM_ERROR_IS_SET(void) \
    (!cpl_errorstate_is_equal(clipm_error_trystate))

/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
#define CLIPM_ERROR_IS_NONE(void) \
    (cpl_errorstate_is_equal(clipm_error_trystate))

/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
#define CLIPM_TRY_CHECK(condition, code, object, msg) \
do { \
    if (!(condition)) \
    { \
        CLIPM_ERROR_SET_MSG( (code), (object), (msg)); \
        CLIPM_TRY_EXIT(); \
    } \
} while (0)

/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
#define CLIPM_TRY_CHECK_AUTOMSG(condition, code) \
do { \
    if (!(condition)) \
    { \
        CLIPM_ERROR_SET_MSG( (code), "!("#condition")", ""); \
        CLIPM_TRY_EXIT(); \
    } \
} while (0)

/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
#define CLIPM_TRY_CHECK_ERROR_STATE(void) \
do { \
    if (CLIPM_ERROR_IS_SET()) \
    { \
        if (!clipm_error_is_set_where) \
            _CLIPM_ERROR_SET_WHERE_(); \
        CLIPM_TRY_EXIT(); \
    } \
} while (0)

/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
#define CLIPM_TRY_ASSERT(condition) \
do { \
    if (!(condition)) \
    { \
        _CLIPM_ERROR_SET_MSG_(              CLIPM_ERROR_UNEXPECTED, \
                                            "!("#condition")", \
                                            _CLIPM_MSG_ERR_UNEXPECTED); \
        CLIPM_TRY_EXIT(); \
    } \
} while (0)

/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
#define CLIPM_TRY_ASSERT_ERROR_STATE(void) \
do { \
    if (CLIPM_ERROR_IS_SET()) \
    { \
        _CLIPM_ERROR_SET_MSG_(              CLIPM_ERROR_UNEXPECTED, \
                                            NULL, \
                                            _CLIPM_MSG_ERR_UNEXPECTED); \
        CLIPM_TRY_EXIT(); \
    } \
} while (0)

/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
#define CLIPM_TRY_EXIT_WITH_ERROR(code) \
do { \
    CLIPM_ERROR_SET((code)); \
    CLIPM_TRY_EXIT(); \
} while (0)

/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
#define CLIPM_TRY_EXIT_WITH_ERROR_MSG(code, object, msg) \
do { \
    CLIPM_ERROR_SET_MSG((code), (object), (msg)); \
    CLIPM_TRY_EXIT(); \
} while (0)

/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
#define CLIPM_TRY_EXIT_IFN(condition) \
do { \
    if (!(condition)) \
    { \
        CLIPM_TRY_ASSERT(CLIPM_ERROR_IS_SET()); \
        if (!clipm_error_is_set_where) \
            _CLIPM_ERROR_SET_WHERE_(); \
        CLIPM_TRY_EXIT(); \
    } \
} while (0)

/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
#define CLIPM_TRY_EXIT(void) \
    goto _CLIPM_CATCH_LABEL_


/*-----------------------------------------------------------------------------
    Declarations
 -----------------------------------------------------------------------------*/

#ifdef __cplusplus
extern "C" {
#endif

/*-----------------------------------------------------------------------------
    Types
 -----------------------------------------------------------------------------*/

typedef enum _clipm_error_code_ {
    CLIPM_ERROR_UNEXPECTED = CPL_ERROR_EOL + 0
} clipm_error_code;

extern const char _CLIPM_MSG_ERR_UNEXPECTED[];
extern const char _CLIPM_MSG_ERR_HANDLING[];

extern const char CLIPM_MSG_ERR_2ROWXY[];
extern const char CLIPM_MSG_ERR_DIFFSIZES[];
extern const char CLIPM_MSG_ERR_DIFFTYPES[];

/*-----------------------------------------------------------------------------
    Prototypes
 -----------------------------------------------------------------------------*/

void        _clipm_priv_error_sprint_messages(
                                            char        *outstr,
                                            const char  *msg1,
                                            const char  *msg2,
                                            size_t      maxlen);

/*----------------------------------------------------------------------------*/

#ifdef __cplusplus
}   /* extern "C" */
#endif

#endif /* CLIPM_PRIV_ERROR_H */