report.h

/*******************************************************************************
 * Copyright 2016, 2018 MINRES Technologies GmbH
 *
 * 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.
 *******************************************************************************/
 
#ifndef _SCC_REPORT_H_
#define _SCC_REPORT_H_
 
#include "utilities.h"
#include <cci_configuration>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <mutex>
#include <sstream>
#include <stdexcept>
#include <sysc/kernel/sc_time.h>
#include <sysc/utils/sc_report.h>
#include <unordered_map>
#include <util/ities.h>
 
#if defined(_MSC_VER) && defined(ERROR)
#undef ERROR
#endif

#define SCC_LOG_LEVEL_PARAM_NAME "log_level"
#define SCC_LOG_LEVEL_PARAM_NAME_LEN 9

namespace scc {
enum class log { NONE, FATAL, ERROR, WARNING, INFO, DEBUG, TRACE, TRACEALL, DBGTRACE = TRACEALL };
namespace {
static std::array<const char* const, 8> log_level_names = {{"NONE", "FATAL", "ERROR", "WARNING", "INFO", "DEBUG", "TRACE", "TRACEALL"}};
static const std::unordered_map<std::string, scc::log> log_level_lut = {
    {"NONE", scc::log::NONE}, {"FATAL", scc::log::FATAL}, {"ERROR", scc::log::ERROR}, {"WARNING", scc::log::WARNING},
    {"INFO", scc::log::INFO}, {"DEBUG", scc::log::DEBUG}, {"TRACE", scc::log::TRACE}, {"TRACEALL", scc::log::TRACEALL}};
} // namespace
inline log as_log(int logLevel) {
    assert(logLevel >= static_cast<int>(log::NONE) && logLevel <= static_cast<int>(log::TRACEALL));
    std::array<const log, 8> m = {{log::NONE, log::FATAL, log::ERROR, log::WARNING, log::INFO, log::DEBUG, log::TRACE, log::TRACEALL}};
    return m[logLevel];
}

inline std::istream& operator>>(std::istream& is, log& val) {
    std::string buf;
    is >> buf;
    auto it = scc::log_level_lut.find(buf);
    if(it == std::end(scc::log_level_lut))
        throw std::out_of_range(std::string("Illegal log level value: ") + buf);
    val = it->second;
    return is;
}

inline std::ostream& operator<<(std::ostream& os, log const& val) {
    os << log_level_names[static_cast<unsigned>(val)];
    return os;
}

void init_logging(log level = log::WARNING, unsigned type_field_width = 24, bool print_time = false);
void reinit_logging();
void reinit_logging(log level);
struct LogConfig {
    log level{log::WARNING};
    unsigned msg_type_field_width{24};
    bool print_sys_time{false};
    bool print_sim_time{true};
    bool print_delta{false};
    bool print_severity{true};
    bool colored_output{true};
    std::string log_file_name{""};
    std::string log_filter_regex{""};
    bool log_async{true};
    bool dont_create_broker{false};
    bool report_only_first_error{false};
    bool instance_based_log_levels{true};
    bool install_handler{true};

    LogConfig& logLevel(log);
    LogConfig& msgTypeFieldWidth(unsigned);
    LogConfig& printSysTime(bool = true);
    LogConfig& printSimTime(bool = true);
    LogConfig& printDelta(bool = true);
    LogConfig& printSeverity(bool = true);
    LogConfig& coloredOutput(bool = true);
    LogConfig& logFileName(std::string&&);
    LogConfig& logFileName(const std::string&);
    LogConfig& logFilterRegex(std::string&&);
    LogConfig& logFilterRegex(const std::string&);
    LogConfig& logAsync(bool = true);
    LogConfig& dontCreateBroker(bool = true);
    LogConfig& reportOnlyFirstError(bool = true);
    LogConfig& instanceBasedLogLevels(bool = true);
    LogConfig& installHandler(bool = true);
};

void init_logging(const LogConfig& log_config);
bool is_logging_initialized();
void set_logging_level(log level);
log get_logging_level();
void set_cycle_base(sc_core::sc_time period);
extern std::mutex verbosity_mtx;
inline sc_core::sc_verbosity get_log_verbosity() {
    return static_cast<sc_core::sc_verbosity>(::sc_core::sc_report_handler::get_verbosity_level());
}

sc_core::sc_verbosity get_log_verbosity(char const* t);
inline sc_core::sc_verbosity get_log_verbosity(std::string const& t) { return get_log_verbosity(t.c_str()); }
template <sc_core::sc_severity SEVERITY> struct ScLogger {
    ScLogger(const char* file, int line, int verbosity = sc_core::SC_MEDIUM)
    : t(nullptr)
    , file(file)
    , line(line)
    , level(verbosity){};
 
    ScLogger() = delete;
 
    ScLogger(const ScLogger&) = delete;
 
    ScLogger(ScLogger&&) = delete;
 
    ScLogger& operator=(const ScLogger&) = delete;
 
    ScLogger& operator=(ScLogger&&) = delete;
    virtual ~ScLogger() noexcept(false) {
        int verb = 100;
        {
            std::lock_guard<std::mutex> lock(verbosity_mtx);
            verb = ::sc_core::sc_report_handler::set_verbosity_level(1000);
        }
        ::sc_core::sc_report_handler::report(SEVERITY, t ? t : "SystemC", os.str().c_str(), level, file, line);
        {
            std::lock_guard<std::mutex> lock(verbosity_mtx);
            ::sc_core::sc_report_handler::set_verbosity_level(verb);
        }
    }

    inline ScLogger& type() {
        this->t = nullptr;
        return *this;
    }

    inline ScLogger& type(char const* t) {
        this->t = const_cast<char*>(t);
        return *this;
    }

    inline ScLogger& type(std::string const& t) {
        this->t = const_cast<char*>(t.c_str());
        return *this;
    }

    inline std::ostream& get() { return os; };
 
protected:
    std::ostringstream os{};
    char* t{nullptr};
    const char* file;
    const int line;
    const int level;
};

#define SCCLOG(lvl, ...) ::scc::ScLogger<::sc_core::SC_INFO>(__FILE__, __LINE__, lvl).type(__VA_ARGS__).get()
#define SCCTRACEALL(...)                                                                                                                   \
    if(::scc::get_log_verbosity(__VA_ARGS__) >= sc_core::SC_DEBUG)                                                                         \
    SCCLOG(sc_core::SC_DEBUG, __VA_ARGS__)
#define SCCTRACE(...)                                                                                                                      \
    if(::scc::get_log_verbosity(__VA_ARGS__) >= sc_core::SC_FULL)                                                                          \
    SCCLOG(sc_core::SC_FULL, __VA_ARGS__)
#define SCCDEBUG(...)                                                                                                                      \
    if(::scc::get_log_verbosity(__VA_ARGS__) >= sc_core::SC_HIGH)                                                                          \
    SCCLOG(sc_core::SC_HIGH, __VA_ARGS__)
#define SCCINFO(...)                                                                                                                       \
    if(::scc::get_log_verbosity(__VA_ARGS__) >= sc_core::SC_MEDIUM)                                                                        \
    SCCLOG(sc_core::SC_MEDIUM, __VA_ARGS__)
#define SCCWARN(...)                                                                                                                       \
    if(::scc::get_log_verbosity(__VA_ARGS__) >= sc_core::SC_LOW)                                                                           \
    ::scc::ScLogger<::sc_core::SC_WARNING>(__FILE__, __LINE__, sc_core::SC_MEDIUM).type(__VA_ARGS__).get()
#define SCCERR(...) ::scc::ScLogger<::sc_core::SC_ERROR>(__FILE__, __LINE__, sc_core::SC_MEDIUM).type(__VA_ARGS__).get()
#define SCCFATAL(...) ::scc::ScLogger<::sc_core::SC_FATAL>(__FILE__, __LINE__, sc_core::SC_MEDIUM).type(__VA_ARGS__).get()
 
#ifdef NDEBUG
#define SCC_ASSERT(expr) ((void)0)
#else
#define SCC_ASSERT(expr) ((void)((expr) ? 0 : (SC_REPORT_FATAL(::sc_core::SC_ID_ASSERTION_FAILED_, #expr), 0)))
#endif
#ifndef SCMOD
#define SCMOD this->name()
#endif
#ifndef SCOBJ
#define SCOBJ this->name()
#endif
class stream_redirection : public std::stringbuf {
public:
    stream_redirection(std::ostream& os, log level);
 
    stream_redirection(stream_redirection const&) = delete;
 
    stream_redirection& operator=(stream_redirection const&) = delete;
 
    stream_redirection(stream_redirection&&) = delete;
 
    stream_redirection& operator=(stream_redirection&&) = delete;
    ~stream_redirection();
    void reset();
 
protected:
    std::streamsize xsputn(const char_type* s, std::streamsize n) override;
    int sync() override;
    std::ostream& os;
    log level;
    std::streambuf* old_buf{nullptr};
};
 
} // namespace scc // end of scc-sysc
namespace cci {
template <> inline bool cci_value_converter<scc::log>::pack(cci_value::reference dst, scc::log const& src) {
    dst.set_string(scc::log_level_names[static_cast<unsigned>(src)]);
    return true;
}
template <> inline bool cci_value_converter<scc::log>::unpack(scc::log& dst, cci_value::const_reference src) {
    // Highly defensive unpacker; probably could check less
    if(!src.is_string())
        return false;
    auto it = scc::log_level_lut.find(src.get_string());
    if(it != std::end(scc::log_level_lut)) {
        dst = it->second;
        return true;
    }
    return false;
}
} // namespace cci
#endif /* _SCC_REPORT_H_ */