error.h

/*
Copyright 2013-present Barefoot Networks, Inc.
 
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
 
    http://www.apache.org/licenses/LICENSE-2.0
 
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
 
/* -*-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 diagnosticCount() {
    return BaseCompileContext::get().errorReporter().getDiagnosticCount();
}
 
// Errors (and warnings) 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)...);
}
 
#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)...);
}
 
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_ */