error_reporter.h

/*
 * SPDX-FileCopyrightText: 2013 Barefoot Networks, Inc.
 * Copyright 2013-present Barefoot Networks, Inc.
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef LIB_ERROR_REPORTER_H_
#define LIB_ERROR_REPORTER_H_
 
#include <iostream>
#include <ostream>
#include <set>
#include <type_traits>
#include <unordered_map>
 
#include <boost/format.hpp>
 
#include "absl/strings/str_format.h"
#include "bug_helper.h"
#include "error_catalog.h"
#include "error_helper.h"
#include "exceptions.h"
 
namespace P4 {

enum class DiagnosticAction {
    Ignore,  
    Info,    
    Warn,    
    Error    
};
 
// Keeps track of compilation errors.
// Errors are specified using the error() and warning() methods,
// that use boost::format format strings, i.e.,
// %1%, %2%, etc (starting at 1, not at 0).
// Some compatibility for printf-style arguments is also supported.
class ErrorReporter {
 protected:
    unsigned int infoCount;
    unsigned int warningCount;
    unsigned int errorCount;
    unsigned int maxErrorCount;  
 
    std::ostream *outputstream;

    std::set<std::pair<int, const Util::SourceInfo>> errorTracker;

    virtual void emit_message(const ErrorMessage &msg) {
        *outputstream << msg.toString();
        outputstream->flush();
    }
 
    virtual void emit_message(const ParserErrorMessage &msg) {
        *outputstream << msg.toString();
        outputstream->flush();
    }

    bool error_reported(int err, const Util::SourceInfo source) {
        if (!source.isValid()) return false;
        auto p = errorTracker.emplace(err, source);
        return !p.second;  // if insertion took place, then we have not seen the error.
    }

    cstring get_error_name(int errorCode) { return ErrorCatalog::getCatalog().getName(errorCode); }
 
 public:
    ErrorReporter()
        : infoCount(0),
          warningCount(0),
          errorCount(0),
          maxErrorCount(20),
          defaultInfoDiagnosticAction(DiagnosticAction::Info),
          defaultWarningDiagnosticAction(DiagnosticAction::Warn) {
        outputstream = &std::cerr;
        ErrorCatalog::getCatalog().initReporter(*this);
    }
    virtual ~ErrorReporter() = default;
 
    // error message for a bug
    template <typename... Args>
    std::string bug_message(const char *format, Args &&...args) {
        boost::format fmt(format);
        // FIXME: This will implicitly take location of the first argument having
        // SourceInfo. Not sure if this always desireable or not.
        return ::P4::bug_helper(fmt, "", "", std::forward<Args>(args)...);
    }
 
    template <typename... Args>
    std::string format_message(const char *format, Args &&...args) {
        boost::format fmt(format);
        return ::P4::error_helper(fmt, std::forward<Args>(args)...).toString();
    }
 
    template <class T, typename = decltype(std::declval<T>()->getSourceInfo()), typename... Args>
    void diagnose(DiagnosticAction action, const int errorCode, const char *format,
                  const char *suffix, T node, Args &&...args) {
        if (!node || error_reported(errorCode, node->getSourceInfo())) return;
 
        if (cstring name = get_error_name(errorCode))
            diagnose(getDiagnosticAction(errorCode, name, action), name.c_str(), format, suffix,
                     node, std::forward<Args>(args)...);
        else
            diagnose(action, nullptr, format, suffix, node, std::forward<Args>(args)...);
    }
 
    template <typename... Args>
    void diagnose(DiagnosticAction action, const int errorCode, const char *format,
                  const char *suffix, Args &&...args) {
        if (cstring name = get_error_name(errorCode))
            diagnose(getDiagnosticAction(errorCode, name, action), name.c_str(), format, suffix,
                     std::forward<Args>(args)...);
        else
            diagnose(action, nullptr, format, suffix, std::forward<Args>(args)...);
    }

    template <typename... Args>
    void diagnose(DiagnosticAction action, const char *diagnosticName, const char *format,
                  const char *suffix, Args &&...args) {
        if (action == DiagnosticAction::Ignore) return;
 
        ErrorMessage::MessageType msgType = ErrorMessage::MessageType::None;
        if (action == DiagnosticAction::Info) {
            // Avoid burying errors in a pile of info messages:
            // don't emit any more info messages if we've emitted errors.
            if (errorCount > 0) return;
 
            infoCount++;
            msgType = ErrorMessage::MessageType::Info;
        } else if (action == DiagnosticAction::Warn) {
            // Avoid burying errors in a pile of warnings: don't emit any more warnings if we've
            // emitted errors.
            if (errorCount > 0) return;
 
            warningCount++;
            msgType = ErrorMessage::MessageType::Warning;
        } else if (action == DiagnosticAction::Error) {
            errorCount++;
            msgType = ErrorMessage::MessageType::Error;
        }
 
        boost::format fmt(format);
        ErrorMessage msg(msgType, diagnosticName ? diagnosticName : "", suffix);
        msg = ::P4::error_helper(fmt, msg, std::forward<Args>(args)...);
        emit_message(msg);
 
        if (errorCount > maxErrorCount)
            FATAL_ERROR("Number of errors exceeded set maximum of %1%", maxErrorCount);
    }
 
    unsigned getErrorCount() const { return errorCount; }
 
    unsigned getMaxErrorCount() const { return maxErrorCount; }
    unsigned setMaxErrorCount(unsigned newMaxCount) {
        auto r = maxErrorCount;
        maxErrorCount = newMaxCount;
        return r;
    }
 
    unsigned getWarningCount() const { return warningCount; }
 
    unsigned getInfoCount() const { return infoCount; }

    unsigned getDiagnosticCount() const { return errorCount + warningCount + infoCount; }
 
    void setOutputStream(std::ostream *stream) { outputstream = stream; }
 
    std::ostream *getOutputStream() const { return outputstream; }

    template <typename T>
    void parser_error(const Util::SourceInfo &location, const T &message) {
        errorCount++;
        std::stringstream ss;
        ss << message;
 
        emit_message(ParserErrorMessage(location, ss.str()));
    }

    template <typename... Args>
    void parser_error(const Util::InputSources *sources, const char *fmt, Args &&...args) {
        errorCount++;
 
        Util::SourcePosition position = sources->getCurrentPosition();
        position--;
 
        // Unfortunately, we cannot go with statically checked format string
        // here as it would require some changes to yyerror
        std::string message;
        if (!absl::FormatUntyped(&message, absl::UntypedFormatSpec(fmt),
                                 {absl::FormatArg(args)...})) {
            BUG("Failed to format string %s", fmt);
        }
 
        emit_message(ParserErrorMessage(Util::SourceInfo(sources, position), std::move(message)));
    }

    DiagnosticAction getDiagnosticAction(int errorCode, cstring diagnostic,
                                         DiagnosticAction defaultAction) {
        // Actions for errors can never be overridden.
        if (ErrorCatalog::getCatalog().isError(errorCode)) return DiagnosticAction::Error;
        auto it = diagnosticActions.find(diagnostic);
        if (it != diagnosticActions.end()) return it->second;
        // if we're dealing with warnings and they have been globally modified
        // (ignored or turned into errors), then return the global default
        if (defaultAction == DiagnosticAction::Warn &&
            defaultWarningDiagnosticAction != DiagnosticAction::Warn)
            return defaultWarningDiagnosticAction;
        return defaultAction;
    }

    void setDiagnosticAction(std::string_view diagnostic, DiagnosticAction action) {
        diagnosticActions[cstring(diagnostic)] = action;
    }

    DiagnosticAction getDefaultWarningDiagnosticAction() { return defaultWarningDiagnosticAction; }

    void setDefaultWarningDiagnosticAction(DiagnosticAction action) {
        defaultWarningDiagnosticAction = action;
    }

    DiagnosticAction getDefaultInfoDiagnosticAction() { return defaultInfoDiagnosticAction; }

    void setDefaultInfoDiagnosticAction(DiagnosticAction action) {
        defaultInfoDiagnosticAction = action;
    }
 
 private:
    DiagnosticAction defaultInfoDiagnosticAction;

    DiagnosticAction defaultWarningDiagnosticAction;

    std::unordered_map<cstring, DiagnosticAction> diagnosticActions;
};
 
}  // namespace P4
 
#endif /* LIB_ERROR_REPORTER_H_ */