lib/exceptions.h

/*
 * SPDX-FileCopyrightText: 2013 Barefoot Networks, Inc.
 * Copyright 2013-present Barefoot Networks, Inc.
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
/* -*-c++-*- */
 
#ifndef LIB_EXCEPTIONS_H_
#define LIB_EXCEPTIONS_H_
 
#include <unistd.h>
 
#include <exception>
#include <string>
#include <utility>
 
#include "absl/strings/str_cat.h"
#include "lib/format.h"
 
namespace P4::Util {
 
// colors to pretty print messages
constexpr char ANSI_RED[] = "\33[31m";
constexpr char ANSI_BLUE[] = "\33[34m";
constexpr char ANSI_CLR[] = "\33[0m";

inline bool is_cerr_redirected() {
    static bool initialized(false);
    static bool is_redir;
    if (!initialized) {
        initialized = true;
        is_redir = ttyname(fileno(stderr)) == nullptr;  // NOLINT(runtime/threadsafe_fn)
    }
    return is_redir;
}

inline const char *cerr_colorize(const char *color) {
    if (is_cerr_redirected()) {
        return "";
    }
    return color;
}

inline const char *cerr_clear_colors() {
    if (is_cerr_redirected()) {
        return "";
    }
    return ANSI_CLR;
}

class P4CExceptionBase : public std::exception {
 protected:
    std::string message;
    void traceCreation() {}
 
 public:
    explicit P4CExceptionBase(std::string formattedMessage) : message(std::move(formattedMessage)) {
        traceCreation();
    }
 
    template <typename... Args>
    explicit P4CExceptionBase(const char *format, Args &&...args) {
        traceCreation();
        message = createBugMessage(format, args...);
    }
 
    [[nodiscard]] const char *what() const noexcept override { return message.c_str(); }
};

class CompilerBug final : public P4CExceptionBase {
 public:
    explicit CompilerBug(std::string formattedMessage)
        : P4CExceptionBase(std::move(formattedMessage)) {
        // Check if output is redirected and if so, then don't color text so that
        // escape characters are not present
        message = absl::StrCat(cerr_colorize(ANSI_RED), "Compiler Bug", cerr_clear_colors(), ":\n",
                               message);
    }
 
    template <typename... Args>
    explicit CompilerBug(const char *format, Args &&...args)
        : CompilerBug(createBugMessage(format, args...)) {}
 
    template <typename... Args>
    CompilerBug(int line, const char *file, const char *format, Args &&...args)
        : P4CExceptionBase(format, std::forward<Args>(args)...) {
        message = absl::StrCat("In file: ", file, ":", line, "\n", cerr_colorize(ANSI_RED),
                               "Compiler Bug", cerr_clear_colors(), ": ", message);
    }
};

class CompilerUnimplemented final : public P4CExceptionBase {
 public:
    template <typename... Args>
    explicit CompilerUnimplemented(const char *format, Args &&...args)
        : P4CExceptionBase(format, std::forward<Args>(args)...) {
        // Do not add colors when redirecting to stderr
        message = absl::StrCat(cerr_colorize(ANSI_BLUE), "Not yet implemented", cerr_clear_colors(),
                               ":\n", message);
    }
 
    template <typename... Args>
    CompilerUnimplemented(int line, const char *file, const char *format, Args &&...args)
        : P4CExceptionBase(format, std::forward<Args>(args)...) {
        message =
            absl::StrCat("In file: ", file, ":", line, "\n", cerr_colorize(ANSI_BLUE),
                         "Unimplemented compiler support", cerr_clear_colors(), ": ", message);
    }
};

class CompilationError : public P4CExceptionBase {
 public:
    template <typename... Args>
    explicit CompilationError(const char *format, Args &&...args)
        : P4CExceptionBase(format, std::forward<Args>(args)...) {}
};

#define BUG(...)                                                      \
    do {                                                              \
        throw P4::Util::CompilerBug(__LINE__, __FILE__, __VA_ARGS__); \
    } while (0)
#define BUG_CHECK(e, ...)           \
    do {                            \
        if (!(e)) BUG(__VA_ARGS__); \
    } while (0)
#define P4C_UNIMPLEMENTED(...)                                                  \
    do {                                                                        \
        throw P4::Util::CompilerUnimplemented(__LINE__, __FILE__, __VA_ARGS__); \
    } while (0)
 
}  // namespace P4::Util

#define FATAL_ERROR(...)                               \
    do {                                               \
        throw P4::Util::CompilationError(__VA_ARGS__); \
    } while (0)
 
#endif /* LIB_EXCEPTIONS_H_ */