icalerror.h

Go to the documentation of this file.

/*======================================================================
  FILE: icalerror.h
  CREATOR: eric 09 May 1999
 
 SPDX-FileCopyrightText: 2000, Eric Busboom <eric@civicknowledge.com>
 
 SPDX-License-Identifier: LGPL-2.1-only OR MPL-2.0
 
 The original code is icalerror.h
======================================================================*/
 
#ifndef ICALERROR_H
#define ICALERROR_H
 
#include "libical_ical_export.h"
#include <assert.h>
#include <stdio.h>

 
#define ICAL_SETERROR_ISFUNC

LIBICAL_ICAL_EXPORT void icalerror_stop_here(void);

LIBICAL_ICAL_EXPORT void icalerror_crash_here(void);
 
#ifndef _MSC_VER
#pragma GCC visibility push(default)
#endif
typedef enum icalerrorenum
{
    ICAL_NO_ERROR = 0,

    ICAL_BADARG_ERROR,

    ICAL_NEWFAILED_ERROR,

    ICAL_ALLOCATION_ERROR,

    ICAL_MALFORMEDDATA_ERROR,

    ICAL_PARSE_ERROR,

    ICAL_INTERNAL_ERROR, /* Like assert --internal consist. prob */

    ICAL_FILE_ERROR,

    ICAL_USAGE_ERROR,

    ICAL_UNIMPLEMENTED_ERROR,

    ICAL_UNKNOWN_ERROR /* Used for problems in input to icalerror_strerror() */
} icalerrorenum;
#ifndef _MSC_VER
#pragma GCC visibility pop
#endif

LIBICAL_ICAL_EXPORT icalerrorenum *icalerrno_return(void);

#define icalerrno (*(icalerrno_return()))

LIBICAL_ICAL_EXPORT void icalerror_set_errors_are_fatal(int fatal);

LIBICAL_ICAL_EXPORT int icalerror_get_errors_are_fatal(void);
 
/* Warning messages */

 
#ifdef __GNUC__ca
#define icalerror_warn(message)                                                        \
    {                                                                                  \
        icalerrprintf("%s(), %s:%d: %s\n", __FUNCTION__, __FILE__, __LINE__, message); \
    }
#else /* __GNU_C__ */
#define icalerror_warn(message)                                    \
    {                                                              \
        icalerrprintf("%s:%d: %s\n", __FILE__, __LINE__, message); \
    }
#endif /* __GNU_C__ */

LIBICAL_ICAL_EXPORT void icalerror_clear_errno(void);

typedef enum icalerrorstate
{
    ICAL_ERROR_FATAL,

    ICAL_ERROR_NONFATAL,

    ICAL_ERROR_DEFAULT,

    ICAL_ERROR_UNKNOWN
} icalerrorstate;

LIBICAL_ICAL_EXPORT const char *icalerror_strerror(icalerrorenum e);

LIBICAL_ICAL_EXPORT const char *icalerror_perror(void);

LIBICAL_ICAL_EXPORT void ical_bt(void);

LIBICAL_ICAL_EXPORT void icalerror_set_error_state(icalerrorenum error, icalerrorstate state);

LIBICAL_ICAL_EXPORT icalerrorstate icalerror_get_error_state(icalerrorenum error);

LIBICAL_ICAL_EXPORT icalerrorenum icalerror_error_from_string(const char *str);

#if !defined(ICAL_SETERROR_ISFUNC)
#define icalerror_set_errno(x)                                 \
    icalerrno = x;                                             \
    if (icalerror_get_error_state(x) == ICAL_ERROR_FATAL ||    \
        (icalerror_get_error_state(x) == ICAL_ERROR_DEFAULT && \
         icalerror_get_errors_are_fatal() == 1)) {             \
        icalerror_warn(icalerror_strerror(x));                 \
        ical_bt();                                             \
        icalassert(0);                                         \
    }                                                          \
    }
#else
LIBICAL_ICAL_EXPORT void icalerror_set_errno(icalerrorenum x);
#endif

 
#if !defined(ICAL_ERRORS_ARE_FATAL)
#define ICAL_ERRORS_ARE_FATAL 0
#endif
 
#if ICAL_ERRORS_ARE_FATAL == 1
#undef NDEBUG
#endif
 
#define icalerror_check_value_type(value, type) ;
#define icalerror_check_property_type(value, type) ;
#define icalerror_check_parameter_type(value, type) ;
#define icalerror_check_component_type(value, type) ;
 
/* Assert with a message */
#if ICAL_ERRORS_ARE_FATAL == 1
 
#ifdef __GNUC__
#define icalerror_assert(test, message)                                                \
    if (!(test)) {                                                                     \
        icalerrprintf("%s(), %s:%d: %s\n", __FUNCTION__, __FILE__, __LINE__, message); \
        icalerror_stop_here();                                                         \
        abort();                                                                       \
    }
#else /*__GNUC__*/
#define icalerror_assert(test, message)                            \
    if (!(test)) {                                                 \
        icalerrprintf("%s:%d: %s\n", __FILE__, __LINE__, message); \
        icalerror_stop_here();                                     \
        abort();                                                   \
    }
#endif /*__GNUC__*/
 
#else /* ICAL_ERRORS_ARE_FATAL */
#define icalerror_assert(test, message)
#endif /* ICAL_ERRORS_ARE_FATAL */

#define icalerror_check_arg(test, arg)          \
    if (!(test)) {                              \
        icalerror_set_errno(ICAL_BADARG_ERROR); \
    }

#define icalerror_check_arg_rv(test, arg)       \
    if (!(test)) {                              \
        icalerror_set_errno(ICAL_BADARG_ERROR); \
        return;                                 \
    }

#define icalerror_check_arg_rz(test, arg)       \
    if (!(test)) {                              \
        icalerror_set_errno(ICAL_BADARG_ERROR); \
        return 0;                               \
    }

#define icalerror_check_arg_re(test, arg, error) \
    if (!(test)) {                               \
        icalerror_stop_here();                   \
        icalassert(0);                           \
        return error;                            \
    }

#define icalerror_check_arg_rx(test, arg, x)    \
    if (!(test)) {                              \
        icalerror_set_errno(ICAL_BADARG_ERROR); \
        return x;                               \
    }
 
/* String interfaces to set an error to NONFATAL and restore it to its original value */

LIBICAL_ICAL_EXPORT icalerrorstate icalerror_supress(const char *error);

LIBICAL_ICAL_EXPORT void icalerror_restore(const char *error, icalerrorstate es);
 
#endif /* !ICALERROR_H */