cstring.hpp

Go to the documentation of this file.

#ifndef BSL_CSTRING_HPP
#define BSL_CSTRING_HPP

#include "cstdint.hpp"
#include "char_type.hpp"
#include "cstr_type.hpp"
#include "discard.hpp"
#include "is_constant_evaluated.hpp"
#include "is_void.hpp"
#include "min_of.hpp"

// Notes: --
// - In general, you should not use these functions as they are not
//   Core Guideline or AUTOSAR compliant. We leverage them internally
//   within the BSL as this is the only way to ensure some of the BSL's
//   APIs have the proper optimizations.
// - We only implement the functions that we need here. Once again, do
//   not rely on this header.
// - The APIs of these functions have been modified to remove the need
//   for conversions as well as ensure sizes are provided (where possible).
//   This means that some of the APIs are our own to ensure there are not
//   issues with name collisions.
// - Instead of calling the builtin functions manually, we rely on the
//   build system to provide the implementation of each of these functions.
//   This allows you to replace these with your compiler's version, or
//   with a static answer to analysis if needed (for example, PRQA does
//   not support these builtins)
// - Each of these functions has safety added to them to ensure crashing is
//   not possible.
// - All function arguments are sent to bsl::discard to ensure you can replace
//   the builtins with static values without getting unused argument errors.
//

namespace bsl
{
    [[maybe_unused]] inline void *
    builtin_memset(void *const dst, bsl::int8 const ch, bsl::uintmax const count) noexcept
    {
        bsl::discard(dst);
        bsl::discard(ch);
        bsl::discard(count);

        if ((nullptr == dst) || (count == 0U)) {
            return nullptr;
        }

        return BSL_BUILTIN_MEMSET;
    }

    [[nodiscard]] inline bsl::int32
    builtin_memcmp(void const *const lhs, void const *const rhs, bsl::uintmax const count) noexcept
    {
        bsl::discard(lhs);
        bsl::discard(rhs);
        bsl::discard(count);

        if ((nullptr == lhs) || (nullptr == rhs) || (0U == count)) {
            return 0;
        }

        return BSL_BUILTIN_MEMCMP;
    }

    [[nodiscard]] inline constexpr bsl::int32
    builtin_strncmp(cstr_type const lhs, cstr_type const rhs, bsl::uintmax const count) noexcept
    {
        bsl::discard(lhs);
        bsl::discard(rhs);
        bsl::discard(count);

        if ((nullptr == lhs) || (nullptr == rhs) || (0U == count)) {
            return 0;
        }

        return BSL_BUILTIN_STRNCMP;
    }

    [[nodiscard]] inline constexpr bsl::uintmax
    builtin_strlen(cstr_type const str) noexcept
    {
        bsl::discard(str);

        if (nullptr == str) {
            return 0U;
        }

        return BSL_BUILTIN_STRLEN;
    }

    [[nodiscard]] inline constexpr cstr_type
    builtin_strnchr(cstr_type const str, char_type const ch, bsl::uintmax const count) noexcept
    {
        bsl::discard(str);
        bsl::discard(ch);
        bsl::discard(count);

        if ((nullptr == str) || (0U == count)) {
            return nullptr;
        }

        return BSL_BUILTIN_CHAR_MEMCHR;
    }
}

#endif