lib/error.h

/*
 * SPDX-FileCopyrightText: 2013 Barefoot Networks, Inc.
 * Copyright 2013-present Barefoot Networks, Inc.
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
/* -*-C++-*- */
 
#ifndef LIB_ERROR_H_
#define LIB_ERROR_H_
 
#include <type_traits>
 
#include "lib/compile_context.h"
#include "lib/cstring.h"
#include "lib/error_reporter.h"
 
// This should eventually be turned to 0 when all the code is converted
#define LEGACY 1
 
namespace P4 {

inline unsigned errorCount() { return BaseCompileContext::get().errorReporter().getErrorCount(); }

inline unsigned warningCount() {
    return BaseCompileContext::get().errorReporter().getWarningCount();
}

inline unsigned infoCount() { return BaseCompileContext::get().errorReporter().getInfoCount(); }

inline unsigned diagnosticCount() {
    return BaseCompileContext::get().errorReporter().getDiagnosticCount();
}
 
// Errors, warnings, and infos are specified using boost::format format strings, i.e.,
// %1%, %2%, etc (starting at 1, not at 0).
// Some compatibility for printf-style arguments is also supported.

// LEGACY: once we transition to error types, this should be deprecated
#if LEGACY
template <typename... Args>
inline void error(const char *format, Args &&...args) {
    auto &context = BaseCompileContext::get();
    auto action = context.getDefaultErrorDiagnosticAction();
    context.errorReporter().diagnose(action, nullptr, format, "", std::forward<Args>(args)...);
}
#endif

template <class T, typename = std::enable_if_t<Util::has_SourceInfo_v<T>>, class... Args>
void error(const int kind, const char *format, const T *node, Args &&...args) {
    auto &context = BaseCompileContext::get();
    auto action = context.getDefaultErrorDiagnosticAction();
    context.errorReporter().diagnose(action, kind, format, "", node, std::forward<Args>(args)...);
}

template <class T, typename = std::enable_if_t<Util::has_SourceInfo_v<T>>, class... Args>
void errorWithSuffix(const int kind, const char *format, const char *suffix, const T *node,
                     Args &&...args) {
    auto &context = BaseCompileContext::get();
    auto action = context.getDefaultErrorDiagnosticAction();
    context.errorReporter().diagnose(action, kind, format, suffix, node,
                                     std::forward<Args>(args)...);
}

template <class T, typename = std::enable_if_t<Util::has_SourceInfo_v<T> && !std::is_pointer_v<T>>,
          class... Args>
void error(const int kind, const char *format, const T &node, Args &&...args) {
    error(kind, format, &node, std::forward<Args>(args)...);
}
 
#if LEGACY
// LEGACY: once we transition to error types, this should be deprecated
template <class T, typename = std::enable_if_t<Util::has_SourceInfo_v<T>>, class... Args>
void error(const char *format, const T *node, Args &&...args) {
    error(ErrorType::LEGACY_ERROR, format, node, std::forward<Args>(args)...);
}

// LEGACY: once we transition to error types, this should be deprecated
template <class T, typename = std::enable_if_t<Util::has_SourceInfo_v<T> && !std::is_pointer_v<T>>,
          class... Args>
void error(const char *format, const T &node, Args &&...args) {
    error(ErrorType::LEGACY_ERROR, format, node, std::forward<Args>(args)...);
}
#endif

template <typename... Args>
void error(const int kind, const char *format, Args &&...args) {
    auto &context = BaseCompileContext::get();
    auto action = context.getDefaultErrorDiagnosticAction();
    context.errorReporter().diagnose(action, kind, format, "", std::forward<Args>(args)...);
}

#define ERROR_CHECK(e, ...)                 \
    do {                                    \
        if (!(e)) ::P4::error(__VA_ARGS__); \
    } while (0)
 
#if LEGACY
template <typename... Args>
inline void warning(const char *format, Args &&...args) {
    auto &context = BaseCompileContext::get();
    auto action = context.getDefaultWarningDiagnosticAction();
    context.errorReporter().diagnose(action, nullptr, format, "", std::forward<Args>(args)...);
}
#endif

template <class T, typename = std::enable_if_t<Util::has_SourceInfo_v<T>>, class... Args>
void warning(const int kind, const char *format, const T *node, Args &&...args) {
    auto &context = BaseCompileContext::get();
    auto action = context.getDefaultWarningDiagnosticAction();
    context.errorReporter().diagnose(action, kind, format, "", node, std::forward<Args>(args)...);
}

template <class T, typename = std::enable_if_t<Util::has_SourceInfo_v<T> && !std::is_pointer_v<T>>,
          class... Args>
void warning(const int kind, const char *format, const T &node, Args &&...args) {
    ::P4::warning(kind, format, &node, std::forward<Args>(args)...);
}

template <typename... Args>
void warning(const int kind, const char *format, Args &&...args) {
    auto &context = BaseCompileContext::get();
    auto action = context.getDefaultWarningDiagnosticAction();
    context.errorReporter().diagnose(action, kind, format, "", std::forward<Args>(args)...);
}

#define WARN_CHECK(e, ...)                    \
    do {                                      \
        if (!(e)) ::P4::warning(__VA_ARGS__); \
    } while (0)

template <class T, typename = std::enable_if_t<Util::has_SourceInfo_v<T>>, class... Args>
void info(const int kind, const char *format, const T *node, Args &&...args) {
    auto &context = BaseCompileContext::get();
    auto action = context.getDefaultInfoDiagnosticAction();
    context.errorReporter().diagnose(action, kind, format, "", node, std::forward<Args>(args)...);
}

template <class T, typename = std::enable_if_t<Util::has_SourceInfo_v<T> && !std::is_pointer_v<T>>,
          class... Args>
void info(const int kind, const char *format, const T &node, Args &&...args) {
    ::P4::info(kind, format, &node, std::forward<Args>(args)...);
}

template <typename... Args>
void info(const int kind, const char *format, Args &&...args) {
    auto &context = BaseCompileContext::get();
    auto action = context.getDefaultInfoDiagnosticAction();
    context.errorReporter().diagnose(action, kind, format, "", std::forward<Args>(args)...);
}
 
}  // namespace P4
 
#endif /* LIB_ERROR_H_ */