// SPDX-License-Identifier: Apache-2.0

// SPDX-FileCopyrightText: Copyright The WasmEdge Authors

//===-- wasmedge/common/errcode.h - Error code definition -----------------===//

//

// Part of the WasmEdge Project.

//

//===----------------------------------------------------------------------===//

///

/// \file

/// This file contains the `Expected` wrappers.

///

//===----------------------------------------------------------------------===//

#pragma once

#include "common/enum_errcode.hpp"

#include "common/expected.h"

#include "common/fmt.h"

#include "common/spdlog.h"

#include "experimental/assume.hpp"

#include <cassert>

#include <ostream>

#include <string>

#include <string_view>

#if defined(_MSC_VER) && !defined(__clang__)

#define __builtin_unreachable() __assume(0)

#endif

#define assuming(R) CXX23_ASSUME(R)

#ifdef NDEBUG

#define assumingUnreachable() __builtin_unreachable()

#else

#define assumingUnreachable()                                                  \

  (assert(false && "unreachable"), __builtin_unreachable())

#endif

namespace WasmEdge {

#if defined(__GNUC__) || defined(__clang__)

#define likely(X) (__builtin_expect(!!(X), 1))

#define unlikely(X) (__builtin_expect(!!(X), 0))

#else

#define likely(X) (!!(X))

#define unlikely(X) (!!(X))

#endif

/// Type aliasing for Expected<T, ErrCode>.

template <typename T> using Expect = Expected<T, ErrCode>;

/// Helper function for Unexpected<ErrCode>.

constexpr auto Unexpect(const ErrCode &Val) { return Unexpected<ErrCode>(Val); }

template <typename... ArgsT> constexpr auto Unexpect(ArgsT... Args) {

  return Unexpected<ErrCode>(ErrCode(Args...));

}

auto WasmEdge::Unexpect<WasmEdge::ErrCode::Value>(WasmEdge::ErrCode::Value)

Line

Count

Source

54

39.7k

template <typename... ArgsT> constexpr auto Unexpect(ArgsT... Args) {

55

39.7k

  return Unexpected<ErrCode>(ErrCode(Args...));

56

39.7k

}

Unexecuted instantiation: auto WasmEdge::Unexpect<WasmEdge::ErrCategory, unsigned int>(WasmEdge::ErrCategory, unsigned int)

template <typename T> constexpr auto Unexpect(const Expect<T> &Val) {

  return Unexpected<ErrCode>(Val.error());

}

auto WasmEdge::Unexpect<void>(cxx20::expected<void, WasmEdge::ErrCode> const&)

Line

Count

Source

57

68

template <typename T> constexpr auto Unexpect(const Expect<T> &Val) {

58

68

  return Unexpected<ErrCode>(Val.error());

59

68

}

Unexecuted instantiation: auto WasmEdge::Unexpect<std::__1::vector<unsigned char, std::__1::allocator<unsigned char> > >(cxx20::expected<std::__1::vector<unsigned char, std::__1::allocator<unsigned char> >, WasmEdge::ErrCode> const&)

} // namespace WasmEdge

template <>

struct fmt::formatter<WasmEdge::ErrCode> : fmt::formatter<std::string_view> {

  template <typename FmtCtx>

  auto format(const WasmEdge::ErrCode &Code,

              FmtCtx &Ctx) WASMEDGE_FMT_CONST noexcept -> decltype(Ctx.out()) {

    using namespace std::literals;

    std::string Output =

        fmt::format("{} failed: {}, Code: 0x{:03x}"sv, Code.getErrCodePhase(),

                    WasmEdge::ErrCodeStr[Code.getEnum()], Code.getCode());

    return formatter<std::string_view>::format(Output, Ctx);

  }

};

template <>

struct fmt::formatter<WasmEdge::ErrCode::Value>

    : fmt::formatter<WasmEdge::ErrCode> {

  template <typename FmtCtx>

  auto format(const WasmEdge::ErrCode::Value &Value,

              FmtCtx &Ctx) WASMEDGE_FMT_CONST noexcept -> decltype(Ctx.out()) {

    return formatter<WasmEdge::ErrCode>::format(WasmEdge::ErrCode(Value), Ctx);

  }

};