2014-02-10 02:10:30 +01:00
|
|
|
/*************************************************************************/
|
|
|
|
|
/* error_macros.h */
|
|
|
|
|
/*************************************************************************/
|
|
|
|
|
/* This file is part of: */
|
|
|
|
|
/* GODOT ENGINE */
|
2017-08-27 14:16:55 +02:00
|
|
|
/* https://godotengine.org */
|
2014-02-10 02:10:30 +01:00
|
|
|
/*************************************************************************/
|
2022-01-13 09:45:09 +01:00
|
|
|
/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur. */
|
|
|
|
|
/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md). */
|
2014-02-10 02:10:30 +01:00
|
|
|
/* */
|
|
|
|
|
/* Permission is hereby granted, free of charge, to any person obtaining */
|
|
|
|
|
/* a copy of this software and associated documentation files (the */
|
|
|
|
|
/* "Software"), to deal in the Software without restriction, including */
|
|
|
|
|
/* without limitation the rights to use, copy, modify, merge, publish, */
|
|
|
|
|
/* distribute, sublicense, and/or sell copies of the Software, and to */
|
|
|
|
|
/* permit persons to whom the Software is furnished to do so, subject to */
|
|
|
|
|
/* the following conditions: */
|
|
|
|
|
/* */
|
|
|
|
|
/* The above copyright notice and this permission notice shall be */
|
|
|
|
|
/* included in all copies or substantial portions of the Software. */
|
|
|
|
|
/* */
|
|
|
|
|
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
|
|
|
|
|
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
|
|
|
|
|
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
|
|
|
|
|
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
|
|
|
|
|
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
|
|
|
|
|
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
|
|
|
|
|
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
|
|
|
|
|
/*************************************************************************/
|
2018-01-05 00:50:27 +01:00
|
|
|
|
2014-02-10 02:10:30 +01:00
|
|
|
#ifndef ERROR_MACROS_H
|
|
|
|
|
#define ERROR_MACROS_H
|
|
|
|
|
|
2021-01-31 13:34:42 +01:00
|
|
|
#include "core/safe_refcount.h"
|
2018-09-11 18:13:45 +02:00
|
|
|
#include "core/typedefs.h"
|
2021-01-31 13:34:42 +01:00
|
|
|
|
2014-02-10 02:10:30 +01:00
|
|
|
/**
|
2018-02-21 17:30:55 +01:00
|
|
|
* Error macros. Unlike exceptions and asserts, these macros try to maintain consistency and stability
|
2020-01-24 16:53:52 +01:00
|
|
|
* inside the code. It is recommended to always return processable data, so in case of an error,
|
|
|
|
|
* the engine can keep working well.
|
2014-02-10 02:10:30 +01:00
|
|
|
* In most cases, bugs and/or invalid data are not fatal and should never allow a perfectly running application
|
|
|
|
|
* to fail or crash.
|
|
|
|
|
*/
|
|
|
|
|
|
2016-03-09 00:00:52 +01:00
|
|
|
/**
|
2019-05-19 12:34:40 +02:00
|
|
|
* Pointer to the error macro printing function. Reassign to any function to have errors printed
|
2014-02-10 02:10:30 +01:00
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
/** Function used by the error macros */
|
|
|
|
|
|
|
|
|
|
// function, file, line, error, explanation
|
|
|
|
|
|
|
|
|
|
enum ErrorHandlerType {
|
|
|
|
|
ERR_HANDLER_ERROR,
|
|
|
|
|
ERR_HANDLER_WARNING,
|
2016-10-10 23:31:01 +02:00
|
|
|
ERR_HANDLER_SCRIPT,
|
|
|
|
|
ERR_HANDLER_SHADER,
|
2014-02-10 02:10:30 +01:00
|
|
|
};
|
|
|
|
|
|
2019-11-06 08:38:23 +01:00
|
|
|
class String;
|
2017-03-05 16:44:50 +01:00
|
|
|
typedef void (*ErrorHandlerFunc)(void *, const char *, const char *, int p_line, const char *, const char *, ErrorHandlerType p_type);
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
|
struct ErrorHandlerList {
|
|
|
|
|
ErrorHandlerFunc errfunc;
|
|
|
|
|
void *userdata;
|
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
ErrorHandlerList *next;
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
ErrorHandlerList() {
|
2021-05-04 16:00:45 +02:00
|
|
|
errfunc = nullptr;
|
|
|
|
|
next = nullptr;
|
|
|
|
|
userdata = nullptr;
|
2017-03-05 16:44:50 +01:00
|
|
|
}
|
2014-02-10 02:10:30 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
void add_error_handler(ErrorHandlerList *p_handler);
|
|
|
|
|
void remove_error_handler(ErrorHandlerList *p_handler);
|
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
void _err_print_error(const char *p_function, const char *p_file, int p_line, const char *p_error, ErrorHandlerType p_type = ERR_HANDLER_ERROR);
|
2019-11-06 08:38:23 +01:00
|
|
|
void _err_print_error(const char *p_function, const char *p_file, int p_line, const String &p_error, ErrorHandlerType p_type = ERR_HANDLER_ERROR);
|
2019-11-10 07:44:31 +01:00
|
|
|
void _err_print_error(const char *p_function, const char *p_file, int p_line, const char *p_error, const char *p_message, ErrorHandlerType p_type = ERR_HANDLER_ERROR);
|
|
|
|
|
void _err_print_error(const char *p_function, const char *p_file, int p_line, const String &p_error, const char *p_message, ErrorHandlerType p_type = ERR_HANDLER_ERROR);
|
|
|
|
|
void _err_print_error(const char *p_function, const char *p_file, int p_line, const char *p_error, const String &p_message, ErrorHandlerType p_type = ERR_HANDLER_ERROR);
|
|
|
|
|
void _err_print_error(const char *p_function, const char *p_file, int p_line, const String &p_error, const String &p_message, ErrorHandlerType p_type = ERR_HANDLER_ERROR);
|
|
|
|
|
void _err_print_index_error(const char *p_function, const char *p_file, int p_line, int64_t p_index, int64_t p_size, const char *p_index_str, const char *p_size_str, const char *p_message = "", bool fatal = false);
|
|
|
|
|
void _err_print_index_error(const char *p_function, const char *p_file, int p_line, int64_t p_index, int64_t p_size, const char *p_index_str, const char *p_size_str, const String &p_message, bool fatal = false);
|
2022-02-05 13:38:57 +01:00
|
|
|
void _err_flush_stdout();
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
|
#ifndef _STR
|
|
|
|
|
#define _STR(m_x) #m_x
|
|
|
|
|
#define _MKSTR(m_x) _STR(m_x)
|
|
|
|
|
#endif
|
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
#define _FNL __FILE__ ":"
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2019-03-24 16:02:04 +01:00
|
|
|
/** An index has failed if m_index<0 or m_index >=m_size, the function exits */
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
|
#ifdef __GNUC__
|
|
|
|
|
//#define FUNCTION_STR __PRETTY_FUNCTION__ - too annoying
|
|
|
|
|
#define FUNCTION_STR __FUNCTION__
|
|
|
|
|
#else
|
|
|
|
|
#define FUNCTION_STR __FUNCTION__
|
|
|
|
|
#endif
|
|
|
|
|
|
2017-05-26 21:11:16 +02:00
|
|
|
// Don't use this directly; instead, use any of the CRASH_* macros
|
|
|
|
|
#ifdef _MSC_VER
|
|
|
|
|
#define GENERATE_TRAP \
|
|
|
|
|
__debugbreak(); \
|
|
|
|
|
/* Avoid warning about control paths */ \
|
|
|
|
|
for (;;) { \
|
|
|
|
|
}
|
|
|
|
|
#else
|
|
|
|
|
#define GENERATE_TRAP __builtin_trap();
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
// (*): See https://stackoverflow.com/questions/257418/do-while-0-what-is-it-good-for
|
|
|
|
|
|
2020-01-24 16:53:52 +01:00
|
|
|
/**
|
|
|
|
|
* If `m_index` is less than 0 or greater than or equal to `m_size`, prints a generic
|
|
|
|
|
* error message and returns from the function. This macro should be preferred to
|
|
|
|
|
* `ERR_FAIL_COND` for bounds checking.
|
|
|
|
|
*/
|
2021-09-12 08:47:33 +02:00
|
|
|
#define ERR_FAIL_INDEX(m_index, m_size) \
|
|
|
|
|
if (unlikely((m_index) < 0 || (m_index) >= (m_size))) { \
|
|
|
|
|
_err_print_index_error(FUNCTION_STR, __FILE__, __LINE__, m_index, m_size, _STR(m_index), _STR(m_size)); \
|
|
|
|
|
return; \
|
|
|
|
|
} else \
|
|
|
|
|
((void)0)
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2020-01-24 16:53:52 +01:00
|
|
|
/**
|
|
|
|
|
* If `m_index` is less than 0 or greater than or equal to `m_size`, prints a custom
|
|
|
|
|
* error message and returns from the function. This macro should be preferred to
|
|
|
|
|
* `ERR_FAIL_COND_MSG` for bounds checking.
|
|
|
|
|
*/
|
2021-10-04 19:45:56 +02:00
|
|
|
#define ERR_FAIL_INDEX_MSG(m_index, m_size, m_msg) \
|
|
|
|
|
if (unlikely((m_index) < 0 || (m_index) >= (m_size))) { \
|
|
|
|
|
_err_print_index_error(FUNCTION_STR, __FILE__, __LINE__, m_index, m_size, _STR(m_index), _STR(m_size), m_msg); \
|
|
|
|
|
return; \
|
|
|
|
|
} else \
|
2021-09-12 08:47:33 +02:00
|
|
|
((void)0)
|
2019-07-28 17:00:50 +02:00
|
|
|
|
2020-01-24 16:53:52 +01:00
|
|
|
/**
|
|
|
|
|
* If `m_index` is less than 0 or greater than or equal to `m_size`,
|
|
|
|
|
* prints a generic error message and returns the value specified in `m_retval`.
|
|
|
|
|
* This macro should be preferred to `ERR_FAIL_COND_V` for bounds checking.
|
|
|
|
|
*/
|
2021-09-12 08:47:33 +02:00
|
|
|
#define ERR_FAIL_INDEX_V(m_index, m_size, m_retval) \
|
|
|
|
|
if (unlikely((m_index) < 0 || (m_index) >= (m_size))) { \
|
|
|
|
|
_err_print_index_error(FUNCTION_STR, __FILE__, __LINE__, m_index, m_size, _STR(m_index), _STR(m_size)); \
|
|
|
|
|
return m_retval; \
|
|
|
|
|
} else \
|
|
|
|
|
((void)0)
|
2017-05-26 21:11:16 +02:00
|
|
|
|
2020-01-24 16:53:52 +01:00
|
|
|
/**
|
|
|
|
|
* If `m_index` is less than 0 or greater than or equal to `m_size`,
|
|
|
|
|
* prints a custom error message and returns the value specified in `m_retval`.
|
|
|
|
|
* This macro should be preferred to `ERR_FAIL_COND_V_MSG` for bounds checking.
|
|
|
|
|
*/
|
2021-10-04 19:45:56 +02:00
|
|
|
#define ERR_FAIL_INDEX_V_MSG(m_index, m_size, m_retval, m_msg) \
|
|
|
|
|
if (unlikely((m_index) < 0 || (m_index) >= (m_size))) { \
|
|
|
|
|
_err_print_index_error(FUNCTION_STR, __FILE__, __LINE__, m_index, m_size, _STR(m_index), _STR(m_size), m_msg); \
|
|
|
|
|
return m_retval; \
|
|
|
|
|
} else \
|
2021-09-12 08:47:33 +02:00
|
|
|
((void)0)
|
2019-07-28 17:00:50 +02:00
|
|
|
|
2020-09-25 18:16:39 +02:00
|
|
|
/**
|
|
|
|
|
* If `m_index` is greater than or equal to `m_size`,
|
|
|
|
|
* prints a generic error message and returns the value specified in `m_retval`.
|
|
|
|
|
* This macro should be preferred to `ERR_FAIL_COND_V` for unsigned bounds checking.
|
|
|
|
|
*/
|
2021-09-12 08:47:33 +02:00
|
|
|
#define ERR_FAIL_UNSIGNED_INDEX(m_index, m_size) \
|
|
|
|
|
if (unlikely((m_index) >= (m_size))) { \
|
|
|
|
|
_err_print_index_error(FUNCTION_STR, __FILE__, __LINE__, m_index, m_size, _STR(m_index), _STR(m_size)); \
|
|
|
|
|
return; \
|
|
|
|
|
} else \
|
|
|
|
|
((void)0)
|
2020-09-25 18:16:39 +02:00
|
|
|
|
2020-01-24 16:53:52 +01:00
|
|
|
/**
|
|
|
|
|
* If `m_index` is greater than or equal to `m_size`,
|
|
|
|
|
* prints a generic error message and returns the value specified in `m_retval`.
|
|
|
|
|
* This macro should be preferred to `ERR_FAIL_COND_V` for unsigned bounds checking.
|
|
|
|
|
*/
|
2021-09-12 08:47:33 +02:00
|
|
|
#define ERR_FAIL_UNSIGNED_INDEX_V(m_index, m_size, m_retval) \
|
|
|
|
|
if (unlikely((m_index) >= (m_size))) { \
|
|
|
|
|
_err_print_index_error(FUNCTION_STR, __FILE__, __LINE__, m_index, m_size, _STR(m_index), _STR(m_size)); \
|
|
|
|
|
return m_retval; \
|
|
|
|
|
} else \
|
|
|
|
|
((void)0)
|
2019-02-20 21:59:03 +01:00
|
|
|
|
2020-01-24 16:53:52 +01:00
|
|
|
/**
|
|
|
|
|
* If `m_index` is greater than or equal to `m_size`,
|
|
|
|
|
* prints a custom error message and returns the value specified in `m_retval`.
|
|
|
|
|
* This macro should be preferred to `ERR_FAIL_COND_V_MSG` for unsigned bounds checking.
|
|
|
|
|
*/
|
2021-10-04 19:45:56 +02:00
|
|
|
#define ERR_FAIL_UNSIGNED_INDEX_V_MSG(m_index, m_size, m_retval, m_msg) \
|
|
|
|
|
if (unlikely((m_index) >= (m_size))) { \
|
|
|
|
|
_err_print_index_error(FUNCTION_STR, __FILE__, __LINE__, m_index, m_size, _STR(m_index), _STR(m_size), m_msg); \
|
|
|
|
|
return m_retval; \
|
|
|
|
|
} else \
|
2021-09-12 08:47:33 +02:00
|
|
|
((void)0)
|
2019-07-28 17:00:50 +02:00
|
|
|
|
2020-01-24 16:53:52 +01:00
|
|
|
/**
|
|
|
|
|
* If `m_index` is less than 0 or greater than or equal to `m_size`,
|
|
|
|
|
* crashes the engine immediately with a generic error message.
|
|
|
|
|
* Only use this if there's no sensible fallback (i.e. the error is unrecoverable).
|
|
|
|
|
* This macro should be preferred to `CRASH_COND` for bounds checking.
|
|
|
|
|
*/
|
2021-09-12 08:47:33 +02:00
|
|
|
#define CRASH_BAD_INDEX(m_index, m_size) \
|
|
|
|
|
if (unlikely((m_index) < 0 || (m_index) >= (m_size))) { \
|
|
|
|
|
_err_print_index_error(FUNCTION_STR, __FILE__, __LINE__, m_index, m_size, _STR(m_index), _STR(m_size), "", true); \
|
2022-02-22 13:49:14 +01:00
|
|
|
_err_flush_stdout(); \
|
2021-09-12 08:47:33 +02:00
|
|
|
GENERATE_TRAP \
|
|
|
|
|
} else \
|
|
|
|
|
((void)0)
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2020-01-24 16:53:52 +01:00
|
|
|
/**
|
|
|
|
|
* If `m_index` is less than 0 or greater than or equal to `m_size`,
|
|
|
|
|
* crashes the engine immediately with a custom error message.
|
|
|
|
|
* Only use this if there's no sensible fallback (i.e. the error is unrecoverable).
|
|
|
|
|
* This macro should be preferred to `CRASH_COND` for bounds checking.
|
|
|
|
|
*/
|
2021-09-12 08:47:33 +02:00
|
|
|
#define CRASH_BAD_INDEX_MSG(m_index, m_size, m_msg) \
|
|
|
|
|
if (unlikely((m_index) < 0 || (m_index) >= (m_size))) { \
|
|
|
|
|
_err_print_index_error(FUNCTION_STR, __FILE__, __LINE__, m_index, m_size, _STR(m_index), _STR(m_size), m_msg, true); \
|
2022-02-22 13:49:14 +01:00
|
|
|
_err_flush_stdout(); \
|
2021-09-12 08:47:33 +02:00
|
|
|
GENERATE_TRAP \
|
|
|
|
|
} else \
|
|
|
|
|
((void)0)
|
2019-07-28 17:00:50 +02:00
|
|
|
|
2020-09-25 18:16:39 +02:00
|
|
|
/**
|
|
|
|
|
* If `m_index` is greater than or equal to `m_size`,
|
|
|
|
|
* crashes the engine immediately with a generic error message.
|
|
|
|
|
* Only use this if there's no sensible fallback (i.e. the error is unrecoverable).
|
|
|
|
|
* This macro should be preferred to `CRASH_COND` for bounds checking.
|
|
|
|
|
*/
|
2021-09-12 08:47:33 +02:00
|
|
|
#define CRASH_BAD_UNSIGNED_INDEX(m_index, m_size) \
|
|
|
|
|
if (unlikely((m_index) >= (m_size))) { \
|
|
|
|
|
_err_print_index_error(FUNCTION_STR, __FILE__, __LINE__, m_index, m_size, _STR(m_index), _STR(m_size), "", true); \
|
2022-02-22 13:49:14 +01:00
|
|
|
_err_flush_stdout(); \
|
2021-09-12 08:47:33 +02:00
|
|
|
GENERATE_TRAP \
|
|
|
|
|
} else \
|
|
|
|
|
((void)0)
|
2020-09-25 18:16:39 +02:00
|
|
|
|
2020-01-24 16:53:52 +01:00
|
|
|
/**
|
|
|
|
|
* If `m_param` is `null`, prints a generic error message and returns from the function.
|
|
|
|
|
*/
|
2021-09-12 08:47:33 +02:00
|
|
|
#define ERR_FAIL_NULL(m_param) \
|
|
|
|
|
if (unlikely(!m_param)) { \
|
|
|
|
|
_err_print_error(FUNCTION_STR, __FILE__, __LINE__, "Parameter \"" _STR(m_param) "\" is null."); \
|
|
|
|
|
return; \
|
|
|
|
|
} else \
|
|
|
|
|
((void)0)
|
2017-03-05 16:44:50 +01:00
|
|
|
|
2020-01-24 16:53:52 +01:00
|
|
|
/**
|
|
|
|
|
* If `m_param` is `null`, prints a custom error message and returns from the function.
|
|
|
|
|
*/
|
2021-10-04 19:45:56 +02:00
|
|
|
#define ERR_FAIL_NULL_MSG(m_param, m_msg) \
|
|
|
|
|
if (unlikely(!m_param)) { \
|
|
|
|
|
_err_print_error(FUNCTION_STR, __FILE__, __LINE__, "Parameter \"" _STR(m_param) "\" is null.", m_msg); \
|
|
|
|
|
return; \
|
|
|
|
|
} else \
|
2021-09-12 08:47:33 +02:00
|
|
|
((void)0)
|
2019-07-28 17:00:50 +02:00
|
|
|
|
2020-01-24 16:53:52 +01:00
|
|
|
/**
|
|
|
|
|
* If `m_param` is `null`, prints a generic error message and returns the value specified in `m_retval`.
|
|
|
|
|
*/
|
2021-09-12 08:47:33 +02:00
|
|
|
#define ERR_FAIL_NULL_V(m_param, m_retval) \
|
|
|
|
|
if (unlikely(!m_param)) { \
|
|
|
|
|
_err_print_error(FUNCTION_STR, __FILE__, __LINE__, "Parameter \"" _STR(m_param) "\" is null."); \
|
|
|
|
|
return m_retval; \
|
|
|
|
|
} else \
|
|
|
|
|
((void)0)
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2020-01-24 16:53:52 +01:00
|
|
|
/**
|
|
|
|
|
* If `m_param` is `null`, prints a custom error message and returns the value specified in `m_retval`.
|
|
|
|
|
*/
|
2021-10-04 19:45:56 +02:00
|
|
|
#define ERR_FAIL_NULL_V_MSG(m_param, m_retval, m_msg) \
|
|
|
|
|
if (unlikely(!m_param)) { \
|
|
|
|
|
_err_print_error(FUNCTION_STR, __FILE__, __LINE__, "Parameter \"" _STR(m_param) "\" is null.", m_msg); \
|
|
|
|
|
return m_retval; \
|
|
|
|
|
} else \
|
2021-09-12 08:47:33 +02:00
|
|
|
((void)0)
|
2019-07-28 17:00:50 +02:00
|
|
|
|
2020-01-24 16:53:52 +01:00
|
|
|
/**
|
|
|
|
|
* If `m_cond` evaluates to `true`, prints a generic error message and returns from the function.
|
2014-02-10 02:10:30 +01:00
|
|
|
*/
|
2021-09-12 08:47:33 +02:00
|
|
|
#define ERR_FAIL_COND(m_cond) \
|
|
|
|
|
if (unlikely(m_cond)) { \
|
|
|
|
|
_err_print_error(FUNCTION_STR, __FILE__, __LINE__, "Condition \"" _STR(m_cond) "\" is true."); \
|
|
|
|
|
return; \
|
|
|
|
|
} else \
|
|
|
|
|
((void)0)
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2020-01-24 16:53:52 +01:00
|
|
|
/**
|
|
|
|
|
* If `m_cond` evaluates to `true`, prints a custom error message and returns from the function.
|
|
|
|
|
*/
|
2021-10-04 19:45:56 +02:00
|
|
|
#define ERR_FAIL_COND_MSG(m_cond, m_msg) \
|
|
|
|
|
if (unlikely(m_cond)) { \
|
|
|
|
|
_err_print_error(FUNCTION_STR, __FILE__, __LINE__, "Condition \"" _STR(m_cond) "\" is true.", m_msg); \
|
|
|
|
|
return; \
|
|
|
|
|
} else \
|
2021-09-12 08:47:33 +02:00
|
|
|
((void)0)
|
2019-07-28 17:00:50 +02:00
|
|
|
|
2020-01-24 16:53:52 +01:00
|
|
|
/**
|
|
|
|
|
* If `m_cond` evaluates to `true`, crashes the engine immediately with a generic error message.
|
|
|
|
|
* Only use this if there's no sensible fallback (i.e. the error is unrecoverable).
|
2017-05-26 21:11:16 +02:00
|
|
|
*/
|
2021-09-12 08:47:33 +02:00
|
|
|
#define CRASH_COND(m_cond) \
|
|
|
|
|
if (unlikely(m_cond)) { \
|
|
|
|
|
_err_print_error(FUNCTION_STR, __FILE__, __LINE__, "FATAL: Condition \"" _STR(m_cond) "\" is true."); \
|
2022-02-22 13:49:14 +01:00
|
|
|
_err_flush_stdout(); \
|
2021-09-12 08:47:33 +02:00
|
|
|
GENERATE_TRAP \
|
|
|
|
|
} else \
|
|
|
|
|
((void)0)
|
2017-05-26 21:11:16 +02:00
|
|
|
|
2020-01-24 16:53:52 +01:00
|
|
|
/**
|
|
|
|
|
* If `m_cond` evaluates to `true`, crashes the engine immediately with a custom error message.
|
|
|
|
|
* Only use this if there's no sensible fallback (i.e. the error is unrecoverable).
|
|
|
|
|
*/
|
2021-10-04 19:45:56 +02:00
|
|
|
#define CRASH_COND_MSG(m_cond, m_msg) \
|
|
|
|
|
if (unlikely(m_cond)) { \
|
|
|
|
|
_err_print_error(FUNCTION_STR, __FILE__, __LINE__, "FATAL: Condition \"" _STR(m_cond) "\" is true.", m_msg); \
|
2022-02-22 13:49:14 +01:00
|
|
|
_err_flush_stdout(); \
|
2021-10-04 19:45:56 +02:00
|
|
|
GENERATE_TRAP \
|
|
|
|
|
} else \
|
2021-09-12 08:47:33 +02:00
|
|
|
((void)0)
|
2019-07-28 17:00:50 +02:00
|
|
|
|
2020-01-24 16:53:52 +01:00
|
|
|
/**
|
|
|
|
|
* If `m_cond` evaluates to `true`, prints a generic error message and returns the value specified in `m_retval`.
|
2014-02-10 02:10:30 +01:00
|
|
|
*/
|
2021-09-12 08:47:33 +02:00
|
|
|
#define ERR_FAIL_COND_V(m_cond, m_retval) \
|
|
|
|
|
if (unlikely(m_cond)) { \
|
|
|
|
|
_err_print_error(FUNCTION_STR, __FILE__, __LINE__, "Condition \"" _STR(m_cond) "\" is true. Returned: " _STR(m_retval)); \
|
|
|
|
|
return m_retval; \
|
|
|
|
|
} else \
|
|
|
|
|
((void)0)
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2020-01-24 16:53:52 +01:00
|
|
|
/**
|
|
|
|
|
* If `m_cond` evaluates to `true`, prints a custom error message and returns the value specified in `m_retval`.
|
|
|
|
|
*/
|
2021-10-04 19:45:56 +02:00
|
|
|
#define ERR_FAIL_COND_V_MSG(m_cond, m_retval, m_msg) \
|
|
|
|
|
if (unlikely(m_cond)) { \
|
|
|
|
|
_err_print_error(FUNCTION_STR, __FILE__, __LINE__, "Condition \"" _STR(m_cond) "\" is true. Returned: " _STR(m_retval), m_msg); \
|
|
|
|
|
return m_retval; \
|
|
|
|
|
} else \
|
2021-09-12 08:47:33 +02:00
|
|
|
((void)0)
|
2019-07-28 17:00:50 +02:00
|
|
|
|
2020-01-24 16:53:52 +01:00
|
|
|
/**
|
|
|
|
|
* If `m_cond` evaluates to `true`, prints a custom error message and continues the loop the macro is located in.
|
2014-02-10 02:10:30 +01:00
|
|
|
*/
|
2021-09-12 08:47:33 +02:00
|
|
|
#define ERR_CONTINUE(m_cond) \
|
|
|
|
|
if (unlikely(m_cond)) { \
|
|
|
|
|
_err_print_error(FUNCTION_STR, __FILE__, __LINE__, "Condition \"" _STR(m_cond) "\" is true. Continuing."); \
|
|
|
|
|
continue; \
|
|
|
|
|
} else \
|
|
|
|
|
((void)0)
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2020-01-24 16:53:52 +01:00
|
|
|
/**
|
|
|
|
|
* If `m_cond` evaluates to `true`, prints a custom error message and continues the loop the macro is located in.
|
|
|
|
|
*/
|
2021-10-04 19:45:56 +02:00
|
|
|
#define ERR_CONTINUE_MSG(m_cond, m_msg) \
|
|
|
|
|
if (unlikely(m_cond)) { \
|
|
|
|
|
_err_print_error(FUNCTION_STR, __FILE__, __LINE__, "Condition \"" _STR(m_cond) "\" is true. Continuing.", m_msg); \
|
|
|
|
|
continue; \
|
|
|
|
|
} else \
|
2021-09-12 08:47:33 +02:00
|
|
|
((void)0)
|
2019-07-28 17:00:50 +02:00
|
|
|
|
2020-01-24 16:53:52 +01:00
|
|
|
/**
|
|
|
|
|
* If `m_cond` evaluates to `true`, prints a generic error message and breaks from the loop the macro is located in.
|
2014-02-10 02:10:30 +01:00
|
|
|
*/
|
2021-09-12 08:47:33 +02:00
|
|
|
#define ERR_BREAK(m_cond) \
|
|
|
|
|
if (unlikely(m_cond)) { \
|
|
|
|
|
_err_print_error(FUNCTION_STR, __FILE__, __LINE__, "Condition \"" _STR(m_cond) "\" is true. Breaking."); \
|
|
|
|
|
break; \
|
|
|
|
|
} else \
|
|
|
|
|
((void)0)
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2020-01-24 16:53:52 +01:00
|
|
|
/**
|
|
|
|
|
* If `m_cond` evaluates to `true`, prints a custom error message and breaks from the loop the macro is located in.
|
|
|
|
|
*/
|
2021-10-04 19:45:56 +02:00
|
|
|
#define ERR_BREAK_MSG(m_cond, m_msg) \
|
|
|
|
|
if (unlikely(m_cond)) { \
|
|
|
|
|
_err_print_error(FUNCTION_STR, __FILE__, __LINE__, "Condition \"" _STR(m_cond) "\" is true. Breaking.", m_msg); \
|
|
|
|
|
break; \
|
|
|
|
|
} else \
|
2021-09-12 08:47:33 +02:00
|
|
|
((void)0)
|
2019-07-28 17:00:50 +02:00
|
|
|
|
2020-01-24 16:53:52 +01:00
|
|
|
/**
|
|
|
|
|
* Prints a generic error message and returns from the function.
|
2014-02-10 02:10:30 +01:00
|
|
|
*/
|
2020-01-24 16:53:52 +01:00
|
|
|
#define ERR_FAIL() \
|
2021-09-12 08:47:33 +02:00
|
|
|
if (true) { \
|
2020-01-24 16:53:52 +01:00
|
|
|
_err_print_error(FUNCTION_STR, __FILE__, __LINE__, "Method failed."); \
|
|
|
|
|
return; \
|
2021-09-12 08:47:33 +02:00
|
|
|
} else \
|
|
|
|
|
((void)0)
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2020-01-24 16:53:52 +01:00
|
|
|
/**
|
|
|
|
|
* Prints a custom error message and returns from the function.
|
|
|
|
|
*/
|
2021-10-04 19:45:56 +02:00
|
|
|
#define ERR_FAIL_MSG(m_msg) \
|
|
|
|
|
if (true) { \
|
|
|
|
|
_err_print_error(FUNCTION_STR, __FILE__, __LINE__, "Method failed.", m_msg); \
|
|
|
|
|
return; \
|
|
|
|
|
} else \
|
2021-09-12 08:47:33 +02:00
|
|
|
((void)0)
|
2019-07-28 17:00:50 +02:00
|
|
|
|
2020-01-24 16:53:52 +01:00
|
|
|
/**
|
|
|
|
|
* Prints a generic error message and returns the value specified in `m_retval`.
|
2017-05-26 21:11:16 +02:00
|
|
|
*/
|
2020-01-24 16:53:52 +01:00
|
|
|
#define ERR_FAIL_V(m_retval) \
|
2021-09-12 08:47:33 +02:00
|
|
|
if (true) { \
|
2020-01-24 16:53:52 +01:00
|
|
|
_err_print_error(FUNCTION_STR, __FILE__, __LINE__, "Method failed. Returning: " __STR(m_retval)); \
|
|
|
|
|
return m_retval; \
|
2021-09-12 08:47:33 +02:00
|
|
|
} else \
|
|
|
|
|
((void)0)
|
2017-05-26 21:11:16 +02:00
|
|
|
|
2020-01-24 16:53:52 +01:00
|
|
|
/**
|
|
|
|
|
* Prints a custom error message and returns the value specified in `m_retval`.
|
|
|
|
|
*/
|
2021-10-04 19:45:56 +02:00
|
|
|
#define ERR_FAIL_V_MSG(m_retval, m_msg) \
|
|
|
|
|
if (true) { \
|
|
|
|
|
_err_print_error(FUNCTION_STR, __FILE__, __LINE__, "Method failed. Returning: " __STR(m_retval), m_msg); \
|
|
|
|
|
return m_retval; \
|
|
|
|
|
} else \
|
2021-09-12 08:47:33 +02:00
|
|
|
((void)0)
|
2017-05-26 21:11:16 +02:00
|
|
|
|
2020-01-24 16:53:52 +01:00
|
|
|
/**
|
|
|
|
|
* Crashes the engine immediately with a generic error message.
|
|
|
|
|
* Only use this if there's no sensible fallback (i.e. the error is unrecoverable).
|
|
|
|
|
*/
|
|
|
|
|
#define CRASH_NOW() \
|
2021-09-12 08:47:33 +02:00
|
|
|
if (true) { \
|
2020-01-24 16:53:52 +01:00
|
|
|
_err_print_error(FUNCTION_STR, __FILE__, __LINE__, "FATAL: Method failed."); \
|
2022-02-22 13:49:14 +01:00
|
|
|
_err_flush_stdout(); \
|
2020-01-24 16:53:52 +01:00
|
|
|
GENERATE_TRAP \
|
2021-09-12 08:47:33 +02:00
|
|
|
} else \
|
|
|
|
|
((void)0)
|
2019-07-28 17:00:50 +02:00
|
|
|
|
2020-01-24 16:53:52 +01:00
|
|
|
/**
|
|
|
|
|
* Crashes the engine immediately with a custom error message.
|
|
|
|
|
* Only use this if there's no sensible fallback (i.e. the error is unrecoverable).
|
2014-02-10 02:10:30 +01:00
|
|
|
*/
|
2021-10-04 19:45:56 +02:00
|
|
|
#define CRASH_NOW_MSG(m_msg) \
|
|
|
|
|
if (true) { \
|
|
|
|
|
_err_print_error(FUNCTION_STR, __FILE__, __LINE__, "FATAL: Method failed.", m_msg); \
|
2022-02-22 13:49:14 +01:00
|
|
|
_err_flush_stdout(); \
|
2021-10-04 19:45:56 +02:00
|
|
|
GENERATE_TRAP \
|
|
|
|
|
} else \
|
2021-09-12 08:47:33 +02:00
|
|
|
((void)0)
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2020-01-24 16:53:52 +01:00
|
|
|
/**
|
|
|
|
|
* Prints an error message without returning.
|
|
|
|
|
*/
|
2021-09-12 08:47:33 +02:00
|
|
|
#define ERR_PRINT(m_string) \
|
|
|
|
|
_err_print_error(FUNCTION_STR, __FILE__, __LINE__, m_string)
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2020-01-24 16:53:52 +01:00
|
|
|
/**
|
|
|
|
|
* Prints an error message without returning, but only do so once in the application lifecycle.
|
|
|
|
|
* This can be used to avoid spamming the console with error messages.
|
|
|
|
|
*/
|
2019-03-01 20:01:21 +01:00
|
|
|
#define ERR_PRINT_ONCE(m_string) \
|
2021-09-12 08:47:33 +02:00
|
|
|
if (true) { \
|
2019-03-01 20:01:21 +01:00
|
|
|
static bool first_print = true; \
|
|
|
|
|
if (first_print) { \
|
|
|
|
|
_err_print_error(FUNCTION_STR, __FILE__, __LINE__, m_string); \
|
|
|
|
|
first_print = false; \
|
|
|
|
|
} \
|
2021-09-12 08:47:33 +02:00
|
|
|
} else \
|
|
|
|
|
((void)0)
|
2019-03-01 20:01:21 +01:00
|
|
|
|
2020-01-24 16:53:52 +01:00
|
|
|
/**
|
|
|
|
|
* Prints a warning message without returning. To warn about deprecated usage,
|
|
|
|
|
* use `WARN_DEPRECATED` or `WARN_DEPRECATED_MSG` instead.
|
2014-02-10 02:10:30 +01:00
|
|
|
*/
|
2021-09-12 08:47:33 +02:00
|
|
|
#define WARN_PRINT(m_string) \
|
|
|
|
|
_err_print_error(FUNCTION_STR, __FILE__, __LINE__, m_string, ERR_HANDLER_WARNING)
|
2017-03-05 16:44:50 +01:00
|
|
|
|
2020-01-24 16:53:52 +01:00
|
|
|
/**
|
|
|
|
|
* Prints a warning message without returning, but only do so once in the application lifecycle.
|
|
|
|
|
* This can be used to avoid spamming the console with warning messages.
|
|
|
|
|
*/
|
2019-03-01 20:01:21 +01:00
|
|
|
#define WARN_PRINT_ONCE(m_string) \
|
2021-09-12 08:47:33 +02:00
|
|
|
if (true) { \
|
2019-03-01 20:01:21 +01:00
|
|
|
static bool first_print = true; \
|
|
|
|
|
if (first_print) { \
|
|
|
|
|
_err_print_error(FUNCTION_STR, __FILE__, __LINE__, m_string, ERR_HANDLER_WARNING); \
|
|
|
|
|
first_print = false; \
|
|
|
|
|
} \
|
2021-09-12 08:47:33 +02:00
|
|
|
} else \
|
|
|
|
|
((void)0)
|
2019-03-01 20:01:21 +01:00
|
|
|
|
2020-01-24 16:53:52 +01:00
|
|
|
/**
|
|
|
|
|
* Prints a generic deprecation warning message without returning.
|
|
|
|
|
* This should be preferred to `WARN_PRINT` for deprecation warnings.
|
|
|
|
|
*/
|
|
|
|
|
#define WARN_DEPRECATED \
|
2021-09-12 08:47:33 +02:00
|
|
|
if (true) { \
|
2021-01-31 13:34:42 +01:00
|
|
|
static SafeFlag warning_shown; \
|
|
|
|
|
if (!warning_shown.is_set()) { \
|
2020-01-24 16:53:52 +01:00
|
|
|
_err_print_error(FUNCTION_STR, __FILE__, __LINE__, "This method has been deprecated and will be removed in the future.", ERR_HANDLER_WARNING); \
|
2021-01-31 13:34:42 +01:00
|
|
|
warning_shown.set(); \
|
2020-01-24 16:53:52 +01:00
|
|
|
} \
|
2021-09-12 08:47:33 +02:00
|
|
|
} else \
|
|
|
|
|
((void)0)
|
2018-04-18 14:10:25 +02:00
|
|
|
|
2020-01-24 16:53:52 +01:00
|
|
|
/**
|
|
|
|
|
* Prints a custom deprecation warning message without returning.
|
|
|
|
|
* This should be preferred to `WARN_PRINT` for deprecation warnings.
|
|
|
|
|
*/
|
|
|
|
|
#define WARN_DEPRECATED_MSG(m_msg) \
|
2021-09-12 08:47:33 +02:00
|
|
|
if (true) { \
|
2021-01-31 13:34:42 +01:00
|
|
|
static SafeFlag warning_shown; \
|
|
|
|
|
if (!warning_shown.is_set()) { \
|
2020-01-24 16:53:52 +01:00
|
|
|
_err_print_error(FUNCTION_STR, __FILE__, __LINE__, "This method has been deprecated and will be removed in the future.", m_msg, ERR_HANDLER_WARNING); \
|
2021-01-31 13:34:42 +01:00
|
|
|
warning_shown.set(); \
|
2020-01-24 16:53:52 +01:00
|
|
|
} \
|
2021-09-12 08:47:33 +02:00
|
|
|
} else \
|
|
|
|
|
((void)0)
|
2019-07-28 17:00:50 +02:00
|
|
|
|
2014-02-10 02:10:30 +01:00
|
|
|
#endif
|
2021-10-04 15:13:43 +02:00
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* This should be a 'free' assert for program flow and should not be needed in any releases,
|
|
|
|
|
* only used in dev builds.
|
|
|
|
|
*/
|
|
|
|
|
#ifdef DEV_ENABLED
|
|
|
|
|
#define DEV_ASSERT(m_cond) \
|
|
|
|
|
if (unlikely(!(m_cond))) { \
|
|
|
|
|
_err_print_error(FUNCTION_STR, __FILE__, __LINE__, "FATAL: DEV_ASSERT failed \"" _STR(m_cond) "\" is false."); \
|
2022-02-22 13:49:14 +01:00
|
|
|
_err_flush_stdout(); \
|
2021-10-04 15:13:43 +02:00
|
|
|
GENERATE_TRAP \
|
|
|
|
|
} else \
|
|
|
|
|
((void)0)
|
|
|
|
|
#else
|
|
|
|
|
#define DEV_ASSERT(m_cond)
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* These should be 'free' checks for program flow and should not be needed in any releases,
|
|
|
|
|
* only used in dev builds.
|
|
|
|
|
*/
|
|
|
|
|
#ifdef DEV_ENABLED
|
|
|
|
|
#define DEV_CHECK(m_cond) \
|
|
|
|
|
if (unlikely(!(m_cond))) { \
|
|
|
|
|
ERR_PRINT("DEV_CHECK failed \"" _STR(m_cond) "\" is false."); \
|
|
|
|
|
} else \
|
|
|
|
|
((void)0)
|
|
|
|
|
#else
|
|
|
|
|
#define DEV_CHECK(m_cond)
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#ifdef DEV_ENABLED
|
|
|
|
|
#define DEV_CHECK_ONCE(m_cond) \
|
|
|
|
|
if (unlikely(!(m_cond))) { \
|
|
|
|
|
ERR_PRINT_ONCE("DEV_CHECK_ONCE failed \"" _STR(m_cond) "\" is false."); \
|
|
|
|
|
} else \
|
|
|
|
|
((void)0)
|
|
|
|
|
#else
|
|
|
|
|
#define DEV_CHECK_ONCE(m_cond)
|
|
|
|
|
#endif
|
