logger.h

Go to the documentation of this file.

#pragma once
 
#ifndef INCLUDED_LOGGER_H_
#define INCLUDED_LOGGER_H_
 
#ifndef INCLUDE_INSIDE_JIT
#include <string>
#include <stdexcept>
#include <stdint.h>
 
#include <algorithm> 
#include <vector>
#include <unordered_set>
#endif
 
#define LOG_PRINTF_FUNCTION  newlang::Logger::log_printf
 
#ifndef NDEBUG
#define LOG_MAKE(level, prefix, ...) LOG_PRINTF_FUNCTION(level, prefix, __FILE__, __LINE__, ##__VA_ARGS__)
#else
#define LOG_MAKE(level, prefix, ...) LOG_PRINTF_FUNCTION(level, prefix, NULL, 0, ##__VA_ARGS__)
#endif
 
#define LOG_THROW(EXCEPT, LEVEL, PREFIX, ...)  throw EXCEPT(LOG_MAKE(LEVEL, PREFIX, ##__VA_ARGS__))
#define LOG_PARSER(format, ...)  LOG_THROW(newlang::ParserError, LOG_LEVEL_ERROR, "P:", format, ##__VA_ARGS__)
#define LOG_RUNTIME(format, ...)  LOG_THROW(std::runtime_error, LOG_LEVEL_ABORT, "R:", format, ##__VA_ARGS__)
 
 
#ifdef BUILD_UNITTEST
// Определения только для юнит-тестов
#define LOG_TEST(...)       LOG_MAKE(LOG_LEVEL_DEBUG, "T:", ##__VA_ARGS__)
#define LOG_TEST_DUMP(...)  LOG_MAKE(LOG_LEVEL_DUMP, "TD:", ##__VA_ARGS__)
#define SCOPE(scope) public
#else
// Исключаются при обычной сборке
#define LOG_TEST(...)
#define LOG_TEST_DUMP(...)
#define SCOPE(scope) scope
#endif
 
 
#ifndef TO_STR
#define TO_STR2(ARG) #ARG
#define TO_STR(ARG) TO_STR2(ARG)
#endif
 
// Use: #pragma message WARNING("My message")
#ifdef _MSC_VER
#define FILE_LINE_LINK __FILE__ "(" TO_STR(__LINE__) ") : "
#define WARNING(exp) (FILE_LINE_LINK "WARNING: " exp)
#else//__GNUC__ - may need other defines for different compilers
#define WARNING(exp) ("WARNING: " exp)
#endif
 
#define STATIC_ASSERT(expr) static_assert((expr), #expr)
 
#define ASSERT_EXCEPTION(text) do { LOG_MAKE(LOG_LEVEL_ABORT, "[ASSERT]:", "%s%s", text, newlang::Logger::GetStackTrace().c_str()); abort(); } while(0)
 
#if defined(BUILD_DEBUG)
#define ASSERT(condition)   do {\
                                if(!(condition)) { \
                                    ASSERT_EXCEPTION(TO_STR(condition)); \
                                }\
                            } while(0)
#define VERIFY(exp) ASSERT(exp)
#else
#define ASSERT(condition)
#define VERIFY(exp) (void)(exp)
#endif
 
 
 
std::string BinToHex(const uint8_t * buffer, const size_t size);
std::string HexStrToBinStr(std::string & hex_str);
 
uint8_t HexToByte(const char c);
size_t HexToBin(const char * str, uint8_t * buffer, const size_t size);
int HexToBinEq(const char * str, const uint8_t * buffer, const size_t size);
size_t BinToHexBuffer(const uint8_t * buffer, const size_t size, char * str, const size_t str_size);
 
 
 
#define LOG_LEVEL_DEFAULT   0
 
#define LOG_LEVEL_DUMP      7
#define LOG_LEVEL_DEBUG     6
#define LOG_LEVEL_INFO      5
#define LOG_LEVEL_WARNING   4
#define LOG_LEVEL_ERROR     3
#define LOG_LEVEL_FAULT     2
#define LOG_LEVEL_ABORT     1
 
#ifndef LOG_LEVEL_MAX
#ifdef NDEBUG
#define LOG_LEVEL_MAX LOG_LEVEL_INFO
#else
#define LOG_LEVEL_MAX LOG_LEVEL_DUMP
#endif
#endif
 
#ifndef LOG_LEVEL_NORMAL
#ifdef NDEBUG
#define LOG_LEVEL_NORMAL LOG_LEVEL_ERROR
#else
#define LOG_LEVEL_NORMAL LOG_LEVEL_INFO
#endif
#endif
 
#if LOG_LEVEL_MAX == LOG_LEVEL_DUMP
#define LOG_DUMP(...)   LOG_MAKE(LOG_LEVEL_DUMP, "DUMP:", ##__VA_ARGS__)
#define LOG_DEBUG(...)   LOG_MAKE(LOG_LEVEL_DEBUG, "D:", ##__VA_ARGS__)
#define LOG_INFO(...)  LOG_MAKE(LOG_LEVEL_INFO, NULL, ##__VA_ARGS__)
#define LOG_WARNING(...)  LOG_MAKE(LOG_LEVEL_WARNING, "W:", ##__VA_ARGS__)
#define LOG_ERROR(...)   LOG_MAKE(LOG_LEVEL_ERROR, "E:", ##__VA_ARGS__)
#define LOG_FAULT(...)  LOG_MAKE(LOG_LEVEL_FAULT, "F:", ##__VA_ARGS__)
#define LOG_ABORT(...)  LOG_MAKE(LOG_LEVEL_ABORT, "A:", ##__VA_ARGS__)
 
#elif LOG_LEVEL_MAX == LOG_LEVEL_DEBUG
#define LOG_DUMP(...)
#define LOG_DEBUG(...)   LOG_MAKE(LOG_LEVEL_DEBUG, "D:", ##__VA_ARGS__)
#define LOG_INFO(...)  LOG_MAKE(LOG_LEVEL_INFO, NULL, ##__VA_ARGS__)
#define LOG_WARNING(...)  LOG_MAKE(LOG_LEVEL_WARNING, "W:", ##__VA_ARGS__)
#define LOG_ERROR(...)   LOG_MAKE(LOG_LEVEL_ERROR, "E:", ##__VA_ARGS__)
#define LOG_FAULT(...)  LOG_MAKE(LOG_LEVEL_FAULT, "F:", ##__VA_ARGS__)
#define LOG_ABORT(...)  LOG_MAKE(LOG_LEVEL_ABORT, "A:", ##__VA_ARGS__)
 
#elif LOG_LEVEL_MAX == LOG_LEVEL_INFO
#define LOG_DUMP(...)
#define LOG_DEBUG(...)   
#define LOG_INFO(...)  LOG_MAKE(LOG_LEVEL_INFO, NULL, ##__VA_ARGS__)
#define LOG_WARNING(...)  LOG_MAKE(LOG_LEVEL_WARNING, "W:", ##__VA_ARGS__)
#define LOG_ERROR(...)   LOG_MAKE(LOG_LEVEL_ERROR, "E:", ##__VA_ARGS__)
#define LOG_FAULT(...)  LOG_MAKE(LOG_LEVEL_FAULT, "F:", ##__VA_ARGS__)
#define LOG_ABORT(...)  LOG_MAKE(LOG_LEVEL_ABORT, "A:", ##__VA_ARGS__)
 
#else
#error Define LOG_LEVEL_MAX value LOG_INFO or higher
#endif
 
#ifndef INCLUDE_INSIDE_JIT
namespace newlang {
 
    // Copy-Past form https://github.com/google/googletest
 
    inline void SplitString(const ::std::string& str, char delimiter,
            ::std::vector< ::std::string>* dest) {
        ::std::vector< ::std::string> parsed;
        ::std::string::size_type pos = 0;
        while (true) {
            const ::std::string::size_type colon = str.find(delimiter, pos);
            if (colon == ::std::string::npos) {
                parsed.push_back(str.substr(pos));
                break;
            } else {
                parsed.push_back(str.substr(pos, colon - pos));
                pos = colon + 1;
            }
        }
        dest->swap(parsed);
    }
    // Returns true if and only if the wildcard pattern matches the string. Each
    // pattern consists of regular characters, single-character wildcards (?), and
    // multi-character wildcards (*).
    // 
    // This function implements a linear-time string globbing algorithm based on
    // https://research.swtch.com/glob.
 
    static bool PatternMatchesString(const std::string& name_str,
            const char* pattern, const char* pattern_end) {
        const char* name = name_str.c_str();
        const char* const name_begin = name;
        const char* const name_end = name + name_str.size();
 
        const char* pattern_next = pattern;
        const char* name_next = name;
 
        while (pattern < pattern_end || name < name_end) {
            if (pattern < pattern_end) {
                switch (*pattern) {
                    default: // Match an ordinary character.
                        if (name < name_end && *name == *pattern) {
                            ++pattern;
                            ++name;
                            continue;
                        }
                        break;
                    case '?': // Match any single character.
                        if (name < name_end) {
                            ++pattern;
                            ++name;
                            continue;
                        }
                        break;
                    case '*':
                        // Match zero or more characters. Start by skipping over the wildcard
                        // and matching zero characters from name. If that fails, restart and
                        // match one more character than the last attempt.
                        pattern_next = pattern;
                        name_next = name + 1;
                        ++pattern;
                        continue;
                }
            }
            // Failed to match a character. Restart if possible.
            if (name_begin < name_next && name_next <= name_end) {
                pattern = pattern_next;
                name = name_next;
                continue;
            }
            return false;
        }
        return true;
    }
 
    inline bool IsGlobPattern(const std::string& pattern) {
        return std::any_of(pattern.begin(), pattern.end(),
                [](const char c) {
                    return c == '?' || c == '*'; });
    }
 
    class StringMatcher {
    public:
        StringMatcher() = default;
 
        // Constructs a filter from a string of patterns separated by `:`.
 
        explicit StringMatcher(const std::string& filter, const char separator = ':') : filter_(filter) {
            // By design "" filter matches "" string.
            std::vector<std::string> all_patterns;
            SplitString(filter, separator, &all_patterns);
            const auto exact_match_patterns_begin = std::partition(
                    all_patterns.begin(), all_patterns.end(), &IsGlobPattern);
 
            glob_patterns_.reserve(exact_match_patterns_begin - all_patterns.begin());
            std::move(all_patterns.begin(), exact_match_patterns_begin,
                    std::inserter(glob_patterns_, glob_patterns_.begin()));
            std::move(
                    exact_match_patterns_begin, all_patterns.end(),
                    std::inserter(exact_match_patterns_, exact_match_patterns_.begin()));
        }
 
        // Returns true if and only if name matches at least one of the patterns in
        // the filter.
 
        bool MatchesName(const std::string& name) const {
            return exact_match_patterns_.count(name) > 0 ||
                    std::any_of(glob_patterns_.begin(), glob_patterns_.end(),
                    [&name](const std::string & pattern) {
                        return PatternMatchesString(
                                name, pattern.c_str(),
                                pattern.c_str() + pattern.size());
                    });
        }
 
        SCOPE(private) :
        const std::string_view filter_;
        std::vector<std::string> glob_patterns_;
        std::unordered_set<std::string> exact_match_patterns_;
    };
 
    //    bool UnitTestOptions::MatchesFilter(const std::string& name_str,
    //            const char* filter) {
    //        return UnitTestFilter(filter).MatchesName(name_str);
    //    }
    //
    //    // Returns true if and only if the user-specified filter matches the test
    //    // suite name and the test name.
    //
    //    bool UnitTestOptions::FilterMatchesTest(const std::string& test_suite_name,
    //            const std::string& test_name) {
    //        // Split --gtest_filter at '-', if there is one, to separate into
    //        // positive filter and negative filter portions
    //        return PositiveAndNegativeUnitTestFilter(GTEST_FLAG_GET(filter))
    //                .MatchesTest(test_suite_name, test_name);
    //    }
    //
 
    class ParserError : public std::runtime_error {
    public:
 
        ParserError(const std::string_view msg) : runtime_error(msg.begin()) {
        }
    };
 
    template <typename T>
    typename std::enable_if < std::is_same<T, std::string>::value, std::string>::type
    DumpToString(const T &obj) {
        return obj;
    }
 
    template <typename T>
    typename std::enable_if < !std::is_same<T, std::string>::value, std::string>::type
    DumpToString(const T &obj) {
        return obj.first;
    }
 
    template<typename T>
    std::string Dump(const T &iterable) {
        std::string result;
        for (auto &elem : iterable) {
            if (!result.empty()) {
                result += '\n';
            }
            result += DumpToString(elem);
        }
        return result;
    }
 
    class Logger {
    public:
        typedef uint8_t LogLevelType;
        typedef void FuncCallback(void *param, LogLevelType level, const char * str, bool flush);
 
        LogLevelType GetLogLevel() {
            return m_level;
        }
 
        LogLevelType GetLogLevelNormal() {
            return LOG_LEVEL_NORMAL;
        }
 
        LogLevelType SetLogLevel(const LogLevelType level) {
            LogLevelType prev_level = m_level;
            if (level >= LOG_LEVEL_ABORT && level <= LOG_LEVEL_MAX) {
                m_level = level;
            } else {
                m_level = LOG_LEVEL_NORMAL;
            }
            return prev_level;
        }
 
        bool SetPrintCallstack(bool enable) {
            bool prev = m_print_callstack;
            m_print_callstack = enable;
            return prev;
        }
 
        bool GetPrintCallstack() {
            return m_print_callstack;
        }
        static std::string GetStackTrace();
 
        static void PrintfCallback(void *, LogLevelType, const char * str, bool flush) {
            fprintf(stdout, "%s", str);
            if (flush) {
                fflush(stdout);
            }
        }
 
        void SetCallback(FuncCallback * func, void * param) {
            m_func = func;
            m_func_param = param;
        }
 
        void SaveCallback(FuncCallback *&func, void * &param) {
            func = m_func;
            param = m_func_param;
        }
 
        static std::string log_printf(uint8_t level, char const *prefix, char const *file, int line, char const *format, ...)
#ifdef __GNUC__
        __attribute__ ((format(printf, 5, 6)))
#endif
        ;
 
        const char * AddString(LogLevelType level, char const *string, bool flush);
        static const char * GetLogLevelDesc(LogLevelType level);
 
        static Logger * Instance() {
            // Шаблон с определением static Logger m_instance; собирается с warning в MinGW
            if (m_instance == nullptr) {
                m_instance = new Logger();
            }
            return m_instance;
        }
        //    private:
 
        Logger() {
            m_level = LOG_LEVEL_NORMAL;
            m_func = &PrintfCallback;
            m_func_param = nullptr;
            m_print_callstack = false;
        }
        Logger(const Logger&) = delete;
        const Logger& operator=(const Logger&) = delete;
 
        virtual ~Logger() {
        }
        static Logger * m_instance;
        LogLevelType m_level;
        FuncCallback *m_func;
        void * m_func_param;
        bool m_print_callstack;
    };
}
 
#endif // INCLUDE_INSIDE_JIT
#endif // INCLUDED_LOGGER_H_