Assert.cpp

Go to the documentation of this file.

#include <Fw/FPrimeBasicTypes.hpp>
#include <Fw/Types/Assert.hpp>
#include <Fw/Types/StringUtils.hpp>
#include <Fw/Types/format.hpp>
#include <cassert>
#include <cstdio>
#include <cstdlib>

#if FW_ASSERT_LEVEL == FW_FILEID_ASSERT
#define fileIdFs "Assert: 0x%08" PRIx32 ":%" PRI_FwSizeType ""
#else
#define fileIdFs "Assert: \"%s:%" PRI_FwSizeType "\""
#endif

namespace Fw {

void defaultPrintAssert(const CHAR* msg) {
    // Write to stderr w/o formatting
    (void)fputs(msg, stderr);
    (void)fputs("\n", stderr);
}

void defaultReportAssert(FILE_NAME_ARG file,
                         FwSizeType lineNo,
                         FwSizeType numArgs,
                         FwAssertArgType arg1,
                         FwAssertArgType arg2,
                         FwAssertArgType arg3,
                         FwAssertArgType arg4,
                         FwAssertArgType arg5,
                         FwAssertArgType arg6,
                         CHAR* destBuffer,
                         FwSizeType buffSize) {
    switch (numArgs) {
        case 0:
            (void)stringFormat(destBuffer, buffSize, fileIdFs, file, lineNo);
            break;
        case 1:
            (void)stringFormat(destBuffer, buffSize, fileIdFs " %" PRI_FwAssertArgType, file, lineNo, arg1);
            break;
        case 2:
            (void)stringFormat(destBuffer, buffSize, fileIdFs " %" PRI_FwAssertArgType " %" PRI_FwAssertArgType, file,
                               lineNo, arg1, arg2);
            break;
        case 3:
            (void)stringFormat(destBuffer, buffSize,
                               fileIdFs " %" PRI_FwAssertArgType " %" PRI_FwAssertArgType " %" PRI_FwAssertArgType,
                               file, lineNo, arg1, arg2, arg3);
            break;
        case 4:
            (void)stringFormat(destBuffer, buffSize,
                               fileIdFs " %" PRI_FwAssertArgType " %" PRI_FwAssertArgType " %" PRI_FwAssertArgType
                                        " %" PRI_FwAssertArgType,
                               file, lineNo, arg1, arg2, arg3, arg4);
            break;
        case 5:
            (void)stringFormat(destBuffer, buffSize,
                               fileIdFs " %" PRI_FwAssertArgType " %" PRI_FwAssertArgType " %" PRI_FwAssertArgType
                                        " %" PRI_FwAssertArgType " %" PRI_FwAssertArgType,
                               file, lineNo, arg1, arg2, arg3, arg4, arg5);
            break;
        case 6:
            (void)stringFormat(destBuffer, buffSize,
                               fileIdFs " %" PRI_FwAssertArgType " %" PRI_FwAssertArgType " %" PRI_FwAssertArgType
                                        " %" PRI_FwAssertArgType " %" PRI_FwAssertArgType " %" PRI_FwAssertArgType,
                               file, lineNo, arg1, arg2, arg3, arg4, arg5, arg6);
            break;
        default:  // in an assert already, what can we do?
            break;
    }
}

void AssertHook::printAssert(const CHAR* msg) {
    defaultPrintAssert(msg);
}

void AssertHook::reportAssert(FILE_NAME_ARG file,
                              FwSizeType lineNo,
                              FwSizeType numArgs,
                              FwAssertArgType arg1,
                              FwAssertArgType arg2,
                              FwAssertArgType arg3,
                              FwAssertArgType arg4,
                              FwAssertArgType arg5,
                              FwAssertArgType arg6) {
    CHAR destBuffer[FW_ASSERT_TEXT_SIZE] = {0};
    defaultReportAssert(file, lineNo, numArgs, arg1, arg2, arg3, arg4, arg5, arg6, destBuffer,
                        static_cast<FwSizeType>(sizeof(destBuffer)));
    // print message
    this->printAssert(destBuffer);
}

void AssertHook::doAssert() {
    assert(false);
}

AssertHook* AssertHook::s_assertHook = nullptr;

void AssertHook::registerHook() {
    this->previousHook = s_assertHook;
    s_assertHook = this;
}

void AssertHook::deregisterHook() {
    s_assertHook = this->previousHook;
}

AssertHook* AssertHook::getRegisteredHook() {
    return s_assertHook;
}

// Default handler of SwAssert functions
FW_ASSERT_NORETURN void defaultSwAssert(FILE_NAME_ARG file,
                                        FwSizeType lineNo,
                                        FwSizeType numArgs,
                                        FwAssertArgType arg1,
                                        FwAssertArgType arg2,
                                        FwAssertArgType arg3,
                                        FwAssertArgType arg4,
                                        FwAssertArgType arg5,
                                        FwAssertArgType arg6) {
    Fw::AssertHook* const registeredHook = Fw::AssertHook::getRegisteredHook();
    if (nullptr == registeredHook) {
        CHAR assertMsg[FW_ASSERT_TEXT_SIZE];
        defaultReportAssert(file, lineNo, numArgs, arg1, arg2, arg3, arg4, arg5, arg6, assertMsg,
                            static_cast<FwSizeType>(sizeof(assertMsg)));
        defaultPrintAssert(assertMsg);
        assert(false);
    } else {
        registeredHook->reportAssert(file, lineNo, numArgs, arg1, arg2, arg3, arg4, arg5, arg6);
        registeredHook->doAssert();
    }
#if FW_ASSERTIONS_ALWAYS_ABORT
    abort();
#endif
}

void SwAssert(FILE_NAME_ARG file, FwSizeType lineNo) {
    defaultSwAssert(file, lineNo, 0, 0, 0, 0, 0, 0, 0);
}

void SwAssert(FILE_NAME_ARG file, FwAssertArgType arg1, FwSizeType lineNo) {
    defaultSwAssert(file, lineNo, 1, arg1, 0, 0, 0, 0, 0);
}

void SwAssert(FILE_NAME_ARG file, FwAssertArgType arg1, FwAssertArgType arg2, FwSizeType lineNo) {
    defaultSwAssert(file, lineNo, 2, arg1, arg2, 0, 0, 0, 0);
}

void SwAssert(FILE_NAME_ARG file, FwAssertArgType arg1, FwAssertArgType arg2, FwAssertArgType arg3, FwSizeType lineNo) {
    defaultSwAssert(file, lineNo, 3, arg1, arg2, arg3, 0, 0, 0);
}

void SwAssert(FILE_NAME_ARG file,
              FwAssertArgType arg1,
              FwAssertArgType arg2,
              FwAssertArgType arg3,
              FwAssertArgType arg4,
              FwSizeType lineNo) {
    defaultSwAssert(file, lineNo, 4, arg1, arg2, arg3, arg4, 0, 0);
}

void SwAssert(FILE_NAME_ARG file,
              FwAssertArgType arg1,
              FwAssertArgType arg2,
              FwAssertArgType arg3,
              FwAssertArgType arg4,
              FwAssertArgType arg5,
              FwSizeType lineNo) {
    defaultSwAssert(file, lineNo, 5, arg1, arg2, arg3, arg4, arg5, 0);
}

void SwAssert(FILE_NAME_ARG file,
              FwAssertArgType arg1,
              FwAssertArgType arg2,
              FwAssertArgType arg3,
              FwAssertArgType arg4,
              FwAssertArgType arg5,
              FwAssertArgType arg6,
              FwSizeType lineNo) {
    defaultSwAssert(file, lineNo, 6, arg1, arg2, arg3, arg4, arg5, arg6);
}
}  // namespace Fw

// define C asserts with C linkage
extern "C" {
I8 CAssert0(FILE_NAME_ARG file, FwSizeType lineNo);
I8 CAssert1(FILE_NAME_ARG file, FwAssertArgType arg1, FwSizeType lineNo);
I8 CAssert2(FILE_NAME_ARG file, FwAssertArgType arg1, FwAssertArgType arg2, FwSizeType lineNo);
I8 CAssert3(FILE_NAME_ARG file, FwAssertArgType arg1, FwAssertArgType arg2, FwAssertArgType arg3, FwSizeType lineNo);
I8 CAssert4(FILE_NAME_ARG file,
            FwAssertArgType arg1,
            FwAssertArgType arg2,
            FwAssertArgType arg3,
            FwAssertArgType arg4,
            FwSizeType lineNo);
I8 CAssert5(FILE_NAME_ARG file,
            FwAssertArgType arg1,
            FwAssertArgType arg2,
            FwAssertArgType arg3,
            FwAssertArgType arg4,
            FwAssertArgType arg5,
            FwSizeType lineNo);
I8 CAssert6(FILE_NAME_ARG file,
            FwAssertArgType arg1,
            FwAssertArgType arg2,
            FwAssertArgType arg3,
            FwAssertArgType arg4,
            FwAssertArgType arg5,
            FwAssertArgType arg6,
            FwSizeType lineNo);
}

I8 CAssert0(FILE_NAME_ARG file, FwSizeType lineNo) {
    Fw::AssertHook* const registeredHook = Fw::AssertHook::getRegisteredHook();
    if (nullptr == registeredHook) {
        CHAR assertMsg[FW_ASSERT_TEXT_SIZE];
        Fw::defaultReportAssert(file, lineNo, 0, 0, 0, 0, 0, 0, 0, assertMsg,
                                static_cast<FwSizeType>(sizeof(assertMsg)));
    } else {
        registeredHook->reportAssert(file, lineNo, 0, 0, 0, 0, 0, 0, 0);
        registeredHook->doAssert();
    }
    return 0;
}

I8 CAssert1(FILE_NAME_ARG file, FwAssertArgType arg1, FwSizeType lineNo) {
    Fw::AssertHook* const registeredHook = Fw::AssertHook::getRegisteredHook();
    if (nullptr == registeredHook) {
        CHAR assertMsg[FW_ASSERT_TEXT_SIZE];
        Fw::defaultReportAssert(file, lineNo, 1, arg1, 0, 0, 0, 0, 0, assertMsg,
                                static_cast<FwSizeType>(sizeof(assertMsg)));
    } else {
        registeredHook->reportAssert(file, lineNo, 1, arg1, 0, 0, 0, 0, 0);
        registeredHook->doAssert();
    }
    return 0;
}

I8 CAssert2(FILE_NAME_ARG file, FwAssertArgType arg1, FwAssertArgType arg2, FwSizeType lineNo) {
    Fw::AssertHook* const registeredHook = Fw::AssertHook::getRegisteredHook();
    if (nullptr == registeredHook) {
        CHAR assertMsg[FW_ASSERT_TEXT_SIZE];
        Fw::defaultReportAssert(file, lineNo, 2, arg1, arg2, 0, 0, 0, 0, assertMsg,
                                static_cast<FwSizeType>(sizeof(assertMsg)));
    } else {
        registeredHook->reportAssert(file, lineNo, 2, arg1, arg2, 0, 0, 0, 0);
        registeredHook->doAssert();
    }
    return 0;
}

I8 CAssert3(FILE_NAME_ARG file, FwAssertArgType arg1, FwAssertArgType arg2, FwAssertArgType arg3, FwSizeType lineNo) {
    Fw::AssertHook* const registeredHook = Fw::AssertHook::getRegisteredHook();
    if (nullptr == registeredHook) {
        CHAR assertMsg[FW_ASSERT_TEXT_SIZE];
        Fw::defaultReportAssert(file, lineNo, 3, arg1, arg2, arg3, 0, 0, 0, assertMsg,
                                static_cast<FwSizeType>(sizeof(assertMsg)));
    } else {
        registeredHook->reportAssert(file, lineNo, 3, arg1, arg2, arg3, 0, 0, 0);
        registeredHook->doAssert();
    }
    return 0;
}

I8 CAssert4(FILE_NAME_ARG file,
            FwAssertArgType arg1,
            FwAssertArgType arg2,
            FwAssertArgType arg3,
            FwAssertArgType arg4,
            FwSizeType lineNo) {
    Fw::AssertHook* const registeredHook = Fw::AssertHook::getRegisteredHook();
    if (nullptr == registeredHook) {
        CHAR assertMsg[FW_ASSERT_TEXT_SIZE];
        Fw::defaultReportAssert(file, lineNo, 4, arg1, arg2, arg3, arg4, 0, 0, assertMsg,
                                static_cast<FwSizeType>(sizeof(assertMsg)));
    } else {
        registeredHook->reportAssert(file, lineNo, 4, arg1, arg2, arg3, arg4, 0, 0);
        registeredHook->doAssert();
    }
    return 0;
}

I8 CAssert5(FILE_NAME_ARG file,
            FwAssertArgType arg1,
            FwAssertArgType arg2,
            FwAssertArgType arg3,
            FwAssertArgType arg4,
            FwAssertArgType arg5,
            FwSizeType lineNo) {
    Fw::AssertHook* const registeredHook = Fw::AssertHook::getRegisteredHook();
    if (nullptr == registeredHook) {
        CHAR assertMsg[FW_ASSERT_TEXT_SIZE];
        Fw::defaultReportAssert(file, lineNo, 5, arg1, arg2, arg3, arg4, arg5, 0, assertMsg,
                                static_cast<FwSizeType>(sizeof(assertMsg)));
    } else {
        registeredHook->reportAssert(file, lineNo, 5, arg1, arg2, arg3, arg4, arg5, 0);
        registeredHook->doAssert();
    }
    return 0;
}

I8 CAssert6(FILE_NAME_ARG file,
            FwAssertArgType arg1,
            FwAssertArgType arg2,
            FwAssertArgType arg3,
            FwAssertArgType arg4,
            FwAssertArgType arg5,
            FwAssertArgType arg6,
            FwSizeType lineNo) {
    Fw::AssertHook* const registeredHook = Fw::AssertHook::getRegisteredHook();
    if (nullptr == registeredHook) {
        CHAR assertMsg[FW_ASSERT_TEXT_SIZE];
        Fw::defaultReportAssert(file, lineNo, 6, arg1, arg2, arg3, arg4, arg5, arg6, assertMsg,
                                static_cast<FwSizeType>(sizeof(assertMsg)));
    } else {
        registeredHook->reportAssert(file, lineNo, 6, arg1, arg2, arg3, arg4, arg5, arg6);
        registeredHook->doAssert();
    }
    return 0;
}