ra8_check.h

Go to the documentation of this file.

 
#pragma once
 
#ifdef __cplusplus
extern "C" {
#endif
 
#include <stdint.h>
 
#include "ra8_err.h"
#include "ra8_log.h"
 
/* =============================================================================
 * Fatal-error sink
 * =============================================================================
 */
 
/* ra8_fatal_error is declared in ra8_error_handler.h. Include
 * it here so RA8_ASSERT / RA8_ERROR_CHECK can call it without the caller
 * having to pull in the other header. */
#include "ra8_error_handler.h"
 
/* =============================================================================
 * Static assertion -- enforces compile-time invariants
 * =============================================================================
 */

#define RA8_STATIC_ASSERT(cond, msg) static_assert((cond), msg)
 
/* =============================================================================
 * Runtime assertion
 * =============================================================================
 */

#define RA8_ASSERT(condition, message)                                                             \
  do {                                                                                             \
    if (!(condition)) {                                                                            \
      ra8_fatal_error("ASSERT", (message), (uint32_t)k_ra8_err_validation_failed);                 \
    }                                                                                              \
  } while (0)
 
/* =============================================================================
 * Error propagation
 * =============================================================================
 */

#define RA8_ERROR_CHECK(err)                                                                       \
  do {                                                                                             \
    ra8_err_t err_rc_ = (err);                                                                     \
    if (ra8_err_is_error(err_rc_)) {                                                               \
      ra8_fatal_error("ERROR_CHECK", "Fatal error", (uint32_t)err_rc_);                            \
    }                                                                                              \
  } while (0)

#define RA8_ERROR_CHECK_NO_ABORT(err)                                                              \
  do {                                                                                             \
    ra8_err_t err_rc_ = (err);                                                                     \
    if (ra8_err_is_error(err_rc_)) {                                                               \
      ra8_log_error_val("ERROR_CHECK", "Non-fatal error", (uint32_t)err_rc_);                      \
    }                                                                                              \
  } while (0)

#define RA8_RETURN_ON_ERROR(err, tag, message)                                                     \
  do {                                                                                             \
    ra8_err_t err_rc_ = (err);                                                                     \
    if (ra8_err_is_error(err_rc_)) {                                                               \
      ra8_log_error((tag), (message));                                                             \
      ra8_log_error_val((tag), "Error", (uint32_t)err_rc_);                                        \
      return err_rc_;                                                                              \
    }                                                                                              \
  } while (0)

#define RA8_RETURN_VOID_ON_ERROR(err, tag, message)                                                \
  do {                                                                                             \
    ra8_err_t err_rc_ = (err);                                                                     \
    if (ra8_err_is_error(err_rc_)) {                                                               \
      ra8_log_error((tag), (message));                                                             \
      ra8_log_error_val((tag), "Error", (uint32_t)err_rc_);                                        \
      return;                                                                                      \
    }                                                                                              \
  } while (0)

#define RA8_RETURN_NULL_ON_ERROR(err, tag, message)                                                \
  do {                                                                                             \
    ra8_err_t err_rc_ = (err);                                                                     \
    if (ra8_err_is_error(err_rc_)) {                                                               \
      ra8_log_error((tag), (message));                                                             \
      ra8_log_error_val((tag), "Error", (uint32_t)err_rc_);                                        \
      return nullptr;                                                                              \
    }                                                                                              \
  } while (0)
 
/* =============================================================================
 * Precondition checks
 * =============================================================================
 */

#define RA8_CHECK_NULL_PTR(ptr, tag, message)                                                      \
  do {                                                                                             \
    if ((ptr) == nullptr) {                                                                        \
      ra8_log_error((tag), (message));                                                             \
      return k_ra8_err_null_ptr;                                                                   \
    }                                                                                              \
  } while (0)

#define RA8_CHECK_NULL_PTR_RETURN(ptr, return_value, tag, message)                                 \
  do {                                                                                             \
    if ((ptr) == nullptr) {                                                                        \
      ra8_log_error((tag), (message));                                                             \
      return (return_value);                                                                       \
    }                                                                                              \
  } while (0)

#define RA8_CHECK_RANGE(value, min, max, errcode)                                                  \
  do {                                                                                             \
    if (((value) < (min)) || ((value) > (max))) {                                                  \
      ra8_log_error("CHECK", "Range check failed");                                                \
      return (errcode);                                                                            \
    }                                                                                              \
  } while (0)

#define RA8_CHECK_RANGE_TAG(value, min, max, errcode, tag)                                         \
  do {                                                                                             \
    (void)(min);                                                                                   \
    if ((value) > (max)) {                                                                         \
      ra8_log_error((tag), "Range check failed");                                                  \
      return (errcode);                                                                            \
    }                                                                                              \
  } while (0)

#define RA8_VALIDATE_PTR(ptr, tag, message) RA8_CHECK_NULL_PTR(ptr, tag, message)

#define RA8_VALIDATE_INIT(initialized, tag, message)                                               \
  do {                                                                                             \
    if (!(initialized)) {                                                                          \
      ra8_log_error((tag), (message));                                                             \
      return k_ra8_err_not_initialized;                                                            \
    }                                                                                              \
  } while (0)
 
#ifdef __cplusplus
}
#endif