MMKV/Core/MMKVLog.cpp

/*
 * Tencent is pleased to support the open source community by making
 * MMKV available.
 *
 * Copyright (C) 2019 THL A29 Limited, a Tencent company.
 * All rights reserved.
 *
 * Licensed under the BSD 3-Clause License (the "License"); you may not use
 * this file except in compliance with the License. You may obtain a copy of
 * the License at
 *
 *       https://opensource.org/licenses/BSD-3-Clause
 *
 * 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.
 */

#include "MMKVLog.h"
#ifdef MMKV_WIN32
#include <windows.h>
#endif // MMKV_WIN32


MMKV_NAMESPACE_BEGIN

#ifdef MMKV_DEBUG
MMKVLogLevel g_currentLogLevel = MMKVLogDebug;
#else
MMKVLogLevel g_currentLogLevel = MMKVLogInfo;
#endif

mmkv::LogHandler g_logHandler = nullptr;

#ifndef __FILE_NAME__
const char *_getFileName(const char *path) {
    const char *ptr = strrchr(path, '/');
    if (!ptr) {
        ptr = strrchr(path, '\\');
    }
    if (ptr) {
        return ptr + 1;
    } else {
        return path;
    }
}
#endif

MMKV_NAMESPACE_END


#ifdef ENABLE_MMKV_LOG
#    include <cstdarg>
#    include <string>

using namespace mmkv;

#    ifndef MMKV_ANDROID

static const char *MMKVLogLevelDesc(MMKVLogLevel level) {
    switch (level) {
        case MMKVLogDebug:
            return "D";
        case MMKVLogInfo:
            return "I";
        case MMKVLogWarning:
            return "W";
        case MMKVLogError:
            return "E";
        default:
            return "N";
    }
}

#        ifdef MMKV_APPLE

void _MMKVLogWithLevel(MMKVLogLevel level, const char *filename, const char *func, int line, const char *format, ...) {
    if (level >= g_currentLogLevel) {
        NSString *nsFormat = [NSString stringWithUTF8String:format];
        va_list argList;
        va_start(argList, format);
        NSString *message = [[NSString alloc] initWithFormat:nsFormat arguments:argList];
        va_end(argList);

        if (g_logHandler) {
            g_logHandler(level, filename, line, func, message);
        } else {
            NSLog(@"[%s] <%s:%d::%s> %@", MMKVLogLevelDesc(level), filename, line, func, message);
        }
    }
}

#        else

//#if defined(MMKV_WIN32)
//inline std::string WideToUTF8(const wchar_t* wstr) {
//    if (!wstr || *wstr == L'\0') {
//        return "";
//    }
//    int u8len = WideCharToMultiByte(CP_UTF8, 0, wstr, -1, nullptr, 0, nullptr, nullptr);
//    if (u8len <= 1) {
//        return ""; // Only null terminator or error
//    }
//    std::string utf8Result(u8len - 1, '\0');
//    WideCharToMultiByte(CP_UTF8, 0, wstr, -1, &utf8Result[0], u8len, nullptr, nullptr);
//    return utf8Result;
//}
//
//void _MMKVLogWithLevel(MMKVLogLevel level, const char* filename, const char* func, int line, const wchar_t* format, ...) {
//    if (level >= g_currentLogLevel) {
//        wchar_t translatedBuf[128];
//        size_t i = 0, j = 0;
//
//        // quick stack-based translation: %s -> %S
//        // allow narrow char* args to work with a wchar_t* format string.
//        while (format[i] != L'\0' && j < 128-2) {
//            if (format[i] == L'%' && format[i + 1] == L's') {
//                translatedBuf[j++] = L'%';
//                translatedBuf[j++] = L'S'; // Force Win32 to treat next arg as narrow char*
//                i += 2;
//            } else {
//                translatedBuf[j++] = format[i++];
//            }
//        }
//        translatedBuf[j] = L'\0';
//
//        std::string message;
//        wchar_t buffer[64];
//        int bufferSize = static_cast<int>(sizeof(buffer) / sizeof(wchar_t));
//
//        va_list args;
//        va_start(args, format);
//        auto length = _vsnwprintf_s(buffer, bufferSize, _TRUNCATE, translatedBuf, args);
//        va_end(args);
//
//        if (length > 0 && length < bufferSize) {
//            message = WideToUTF8(buffer);
//        } else {
//            va_start(args, format);
//            length = _vscwprintf(translatedBuf, args);
//            va_end(args);
//
//            if (length > 0) {
//                std::wstring heapWStr(length, L'\0');
//                va_start(args, format);
//                _vsnwprintf_s(heapWStr.data(), heapWStr.size() + 1, _TRUNCATE, translatedBuf, args);
//                va_end(args);
//                message = WideToUTF8(heapWStr.c_str());
//            }
//        }
//
//        if (g_logHandler) {
//            g_logHandler(level, filename, line, func, message);
//        } else {
//            printf("[%s] <%s:%d::%s> %s\n", MMKVLogLevelDesc(level), filename, line, func, message.c_str());
//            //fflush(stdout);
//        }
//    }
//}
//#endif

void _MMKVLogWithLevel(MMKVLogLevel level, const char *filename, const char *func, int line, const char *format, ...) {
    if (level >= g_currentLogLevel) {
        std::string message;
        char buffer[16];

        va_list args;
        va_start(args, format);
        auto length = std::vsnprintf(buffer, sizeof(buffer), format, args);
        va_end(args);

        if (length < 0) { // something wrong
            message = {};
        } else if (length < sizeof(buffer)) {
            message = std::string(buffer, static_cast<unsigned long>(length));
        } else {
            message.resize(static_cast<unsigned long>(length), '\0');
            va_start(args, format);
            std::vsnprintf(const_cast<char *>(message.data()), static_cast<size_t>(length) + 1, format, args);
            va_end(args);
        }

        if (g_logHandler) {
            g_logHandler(level, filename, line, func, message);
        } else {
            printf("[%s] <%s:%d::%s> %s\n", MMKVLogLevelDesc(level), filename, line, func, message.c_str());
            //fflush(stdout);
        }
    }
}

#        endif // MMKV_APPLE

#    endif // MMKV_ANDROID

#endif // ENABLE_MMKV_LOG