qlogging.cpp

Go to the documentation of this file.

// Copyright (C) 2021 The Qt Company Ltd.
// Copyright (C) 2016 Olivier Goffart <ogoffart@woboq.com>
// Copyright (C) 2022 Intel Corporation.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
#include "qglobal_p.h"
#include "qlogging.h"
#include "qlogging_p.h"
#include "qlist.h"
#include "qbytearray.h"
#include "qscopeguard.h"
#include "qstring.h"
#include "qvarlengtharray.h"
#include "qdebug.h"
#include "qmutex.h"
#include <QtCore/private/qlocking_p.h>
#include <QtCore/private/qsimd_p.h>
#include "qloggingcategory.h"
#ifndef QT_BOOTSTRAPPED
#include "qelapsedtimer.h"
#include "qdeadlinetimer.h"
#include "qdatetime.h"
#include "qcoreapplication.h"
#include "qthread.h"
#include "private/qloggingregistry_p.h"
#include "private/qcoreapplication_p.h"
#include <qtcore_tracepoints_p.h>
#endif
#ifdef Q_OS_WIN
#include <qt_windows.h>
#endif
#ifdef Q_CC_MSVC
#include <intrin.h>
#endif
#if QT_CONFIG(slog2)
#include <sys/slog2.h>
#endif
#if __has_include(<paths.h>)
#include <paths.h>
#endif
 
#ifdef Q_OS_ANDROID
#include <android/log.h>
#endif
 
#ifdef Q_OS_DARWIN
#include <QtCore/private/qcore_mac_p.h>
#endif
 
#if QT_CONFIG(journald)
# define SD_JOURNAL_SUPPRESS_LOCATION
# include <systemd/sd-journal.h>
# include <syslog.h>
#endif
#if QT_CONFIG(syslog)
# include <syslog.h>
#endif
#ifdef Q_OS_UNIX
# include <sys/types.h>
# include <sys/stat.h>
# include <unistd.h>
# include "private/qcore_unix_p.h"
#endif
 
#ifdef Q_OS_WASM
#include <emscripten/emscripten.h>
#endif
 
#if QT_CONFIG(slog2)
extern char *__progname;
#endif
 
#ifndef QT_BOOTSTRAPPED
#if __has_include(<cxxabi.h>) && QT_CONFIG(backtrace) && QT_CONFIG(regularexpression)
#  include <qregularexpression.h>
#  if QT_CONFIG(dladdr)
#    include <dlfcn.h>
#  endif
#  include BACKTRACE_HEADER
#  include <cxxabi.h>
#  define QLOGGING_HAVE_BACKTRACE
#endif
 
#if defined(Q_OS_LINUX) && (defined(__GLIBC__) || __has_include(<sys/syscall.h>))
#  include <sys/syscall.h>
 
# if defined(Q_OS_ANDROID) && !defined(SYS_gettid)
#  define SYS_gettid __NR_gettid
# endif
 
static long qt_gettid()
{
    // no error handling
    // this syscall has existed since Linux 2.4.11 and cannot fail
    return syscall(SYS_gettid);
}
#elif defined(Q_OS_DARWIN)
#  include <pthread.h>
static int qt_gettid()
{
    // no error handling: this call cannot fail
    __uint64_t tid;
    pthread_threadid_np(NULL, &tid);
    return tid;
}
#elif defined(Q_OS_FREEBSD_KERNEL) && defined(__FreeBSD_version) && __FreeBSD_version >= 900031
#  include <pthread_np.h>
static int qt_gettid()
{
    return pthread_getthreadid_np();
}
#else
static QT_PREPEND_NAMESPACE(qint64) qt_gettid()
{
    QT_USE_NAMESPACE
    return qintptr(QThread::currentThreadId());
}
#endif
#endif // !QT_BOOTSTRAPPED
 
#include <cstdlib>
#include <algorithm>
#include <memory>
#include <vector>
 
#include <stdio.h>
 
QT_BEGIN_NAMESPACE
 
using namespace Qt::StringLiterals;
 
#ifndef QT_BOOTSTRAPPED
Q_TRACE_POINT(qtcore, qt_message_print, int type, const char *category, const char *function, const char *file, int line, const QString &message);
#endif
 
#if !defined(Q_CC_MSVC_ONLY)
Q_NORETURN
#endif
static void qt_message_fatal(QtMsgType, const QMessageLogContext &context, const QString &message);
static void qt_message_print(QtMsgType, const QMessageLogContext &context, const QString &message);
static void qt_message_print(const QString &message);
 
static int checked_var_value(const char *varname)
{
    // qEnvironmentVariableIntValue returns 0 on both parsing failure and on
    // empty, but we need to distinguish between the two for backwards
    // compatibility reasons.
    QByteArray str = qgetenv(varname);
    if (str.isEmpty())
        return 0;
 
    bool ok;
    int value = str.toInt(&ok, 0);
    return ok ? value : 1;
}
 
static bool is_fatal_count_down(QAtomicInt &n)
{
    // it's fatal if the current value is exactly 1,
    // otherwise decrement if it's non-zero
 
    int v = n.loadRelaxed();
    while (v != 0 && !n.testAndSetRelaxed(v, v - 1, v))
        qYieldCpu();
    return v == 1; // we exited the loop, so either v == 0 or CAS succeeded to set n from v to v-1
}
 
static bool isFatal(QtMsgType msgType)
{
    if (msgType == QtFatalMsg)
        return true;
 
    if (msgType == QtCriticalMsg) {
        static QAtomicInt fatalCriticals = checked_var_value("QT_FATAL_CRITICALS");
        return is_fatal_count_down(fatalCriticals);
    }
 
    if (msgType == QtWarningMsg || msgType == QtCriticalMsg) {
        static QAtomicInt fatalWarnings = checked_var_value("QT_FATAL_WARNINGS");
        return is_fatal_count_down(fatalWarnings);
    }
 
    return false;
}
 
static bool isDefaultCategory(const char *category)
{
    return !category || strcmp(category, "default") == 0;
}
 
static bool systemHasStderr()
{
    return true;
}
 
static bool stderrHasConsoleAttached()
{
    static const bool stderrHasConsoleAttached = []() -> bool {
        if (!systemHasStderr())
            return false;
 
        if (qEnvironmentVariableIntValue("QT_LOGGING_TO_CONSOLE")) {
            fprintf(stderr, "warning: Environment variable QT_LOGGING_TO_CONSOLE is deprecated, use\n"
                            "QT_ASSUME_STDERR_HAS_CONSOLE and/or QT_FORCE_STDERR_LOGGING instead.\n");
            return true;
        }
 
        if (qEnvironmentVariableIntValue("QT_ASSUME_STDERR_HAS_CONSOLE"))
            return true;
 
#if defined(Q_OS_WIN)
        return GetConsoleWindow();
#elif defined(Q_OS_UNIX)
#       ifndef _PATH_TTY
#       define _PATH_TTY "/dev/tty"
#       endif
 
        // If we can open /dev/tty, we have a controlling TTY
        int ttyDevice = -1;
        if ((ttyDevice = qt_safe_open(_PATH_TTY, O_RDONLY)) >= 0) {
            qt_safe_close(ttyDevice);
            return true;
        } else if (errno == ENOENT || errno == EPERM || errno == ENXIO) {
            // Fall back to isatty for some non-critical errors
            return isatty(STDERR_FILENO);
        } else {
            return false;
        }
#else
        return false; // No way to detect if stderr has a console attached
#endif
    }();
 
    return stderrHasConsoleAttached;
}
 
 
namespace QtPrivate {
 
bool shouldLogToStderr()
{
    static bool forceStderrLogging = qEnvironmentVariableIntValue("QT_FORCE_STDERR_LOGGING");
    return forceStderrLogging || stderrHasConsoleAttached();
}
 
 
} // QtPrivate
 
using namespace QtPrivate;
 
#if defined(Q_CC_MSVC_ONLY) && defined(QT_DEBUG) && defined(_DEBUG) && defined(_CRT_ERROR)
static inline void convert_to_wchar_t_elided(wchar_t *d, size_t space, const char *s) noexcept
{
    size_t len = qstrlen(s);
    if (len + 1 > space) {
        const size_t skip = len - space + 4; // 4 for "..." + '\0'
        s += skip;
        len -= skip;
        for (int i = 0; i < 3; ++i)
          *d++ = L'.';
    }
    while (len--)
        *d++ = *s++;
    *d++ = 0;
}
#endif
 
Q_NEVER_INLINE
static QString qt_message(QtMsgType msgType, const QMessageLogContext &context, const char *msg, va_list ap)
{
    QString buf = QString::vasprintf(msg, ap);
    qt_message_print(msgType, context, buf);
    return buf;
}
 
#undef qDebug
void QMessageLogger::debug(const char *msg, ...) const
{
    va_list ap;
    va_start(ap, msg); // use variable arg list
    const QString message = qt_message(QtDebugMsg, context, msg, ap);
    va_end(ap);
 
    if (isFatal(QtDebugMsg))
        qt_message_fatal(QtDebugMsg, context, message);
}
 
 
#undef qInfo
void QMessageLogger::info(const char *msg, ...) const
{
    va_list ap;
    va_start(ap, msg); // use variable arg list
    const QString message = qt_message(QtInfoMsg, context, msg, ap);
    va_end(ap);
 
    if (isFatal(QtInfoMsg))
        qt_message_fatal(QtInfoMsg, context, message);
}
 
void QMessageLogger::debug(const QLoggingCategory &cat, const char *msg, ...) const
{
    if (!cat.isDebugEnabled())
        return;
 
    QMessageLogContext ctxt;
    ctxt.copyContextFrom(context);
    ctxt.category = cat.categoryName();
 
    va_list ap;
    va_start(ap, msg); // use variable arg list
    const QString message = qt_message(QtDebugMsg, ctxt, msg, ap);
    va_end(ap);
 
    if (isFatal(QtDebugMsg))
        qt_message_fatal(QtDebugMsg, ctxt, message);
}
 
void QMessageLogger::debug(QMessageLogger::CategoryFunction catFunc,
                           const char *msg, ...) const
{
    const QLoggingCategory &cat = (*catFunc)();
    if (!cat.isDebugEnabled())
        return;
 
    QMessageLogContext ctxt;
    ctxt.copyContextFrom(context);
    ctxt.category = cat.categoryName();
 
    va_list ap;
    va_start(ap, msg); // use variable arg list
    const QString message = qt_message(QtDebugMsg, ctxt, msg, ap);
    va_end(ap);
 
    if (isFatal(QtDebugMsg))
        qt_message_fatal(QtDebugMsg, ctxt, message);
}
 
#ifndef QT_NO_DEBUG_STREAM
 
QDebug QMessageLogger::debug() const
{
    QDebug dbg = QDebug(QtDebugMsg);
    QMessageLogContext &ctxt = dbg.stream->context;
    ctxt.copyContextFrom(context);
    return dbg;
}
 
QDebug QMessageLogger::debug(const QLoggingCategory &cat) const
{
    QDebug dbg = QDebug(QtDebugMsg);
    if (!cat.isDebugEnabled())
        dbg.stream->message_output = false;
 
    QMessageLogContext &ctxt = dbg.stream->context;
    ctxt.copyContextFrom(context);
    ctxt.category = cat.categoryName();
 
    return dbg;
}
 
QDebug QMessageLogger::debug(QMessageLogger::CategoryFunction catFunc) const
{
    return debug((*catFunc)());
}
 
QNoDebug QMessageLogger::noDebug() const noexcept
{
    return QNoDebug();
}
 
#endif
 
void QMessageLogger::info(const QLoggingCategory &cat, const char *msg, ...) const
{
    if (!cat.isInfoEnabled())
        return;
 
    QMessageLogContext ctxt;
    ctxt.copyContextFrom(context);
    ctxt.category = cat.categoryName();
 
    va_list ap;
    va_start(ap, msg); // use variable arg list
    const QString message = qt_message(QtInfoMsg, ctxt, msg, ap);
    va_end(ap);
 
    if (isFatal(QtInfoMsg))
        qt_message_fatal(QtInfoMsg, ctxt, message);
}
 
void QMessageLogger::info(QMessageLogger::CategoryFunction catFunc,
                           const char *msg, ...) const
{
    const QLoggingCategory &cat = (*catFunc)();
    if (!cat.isInfoEnabled())
        return;
 
    QMessageLogContext ctxt;
    ctxt.copyContextFrom(context);
    ctxt.category = cat.categoryName();
 
    va_list ap;
    va_start(ap, msg); // use variable arg list
    const QString message = qt_message(QtInfoMsg, ctxt, msg, ap);
    va_end(ap);
 
    if (isFatal(QtInfoMsg))
        qt_message_fatal(QtInfoMsg, ctxt, message);
}
 
#ifndef QT_NO_DEBUG_STREAM
 
QDebug QMessageLogger::info() const
{
    QDebug dbg = QDebug(QtInfoMsg);
    QMessageLogContext &ctxt = dbg.stream->context;
    ctxt.copyContextFrom(context);
    return dbg;
}
 
QDebug QMessageLogger::info(const QLoggingCategory &cat) const
{
    QDebug dbg = QDebug(QtInfoMsg);
    if (!cat.isInfoEnabled())
        dbg.stream->message_output = false;
 
    QMessageLogContext &ctxt = dbg.stream->context;
    ctxt.copyContextFrom(context);
    ctxt.category = cat.categoryName();
 
    return dbg;
}
 
QDebug QMessageLogger::info(QMessageLogger::CategoryFunction catFunc) const
{
    return info((*catFunc)());
}
 
#endif
 
#undef qWarning
void QMessageLogger::warning(const char *msg, ...) const
{
    va_list ap;
    va_start(ap, msg); // use variable arg list
    const QString message = qt_message(QtWarningMsg, context, msg, ap);
    va_end(ap);
 
    if (isFatal(QtWarningMsg))
        qt_message_fatal(QtWarningMsg, context, message);
}
 
void QMessageLogger::warning(const QLoggingCategory &cat, const char *msg, ...) const
{
    if (!cat.isWarningEnabled())
        return;
 
    QMessageLogContext ctxt;
    ctxt.copyContextFrom(context);
    ctxt.category = cat.categoryName();
 
    va_list ap;
    va_start(ap, msg); // use variable arg list
    const QString message = qt_message(QtWarningMsg, ctxt, msg, ap);
    va_end(ap);
 
    if (isFatal(QtWarningMsg))
        qt_message_fatal(QtWarningMsg, ctxt, message);
}
 
void QMessageLogger::warning(QMessageLogger::CategoryFunction catFunc,
                             const char *msg, ...) const
{
    const QLoggingCategory &cat = (*catFunc)();
    if (!cat.isWarningEnabled())
        return;
 
    QMessageLogContext ctxt;
    ctxt.copyContextFrom(context);
    ctxt.category = cat.categoryName();
 
    va_list ap;
    va_start(ap, msg); // use variable arg list
    const QString message = qt_message(QtWarningMsg, ctxt, msg, ap);
    va_end(ap);
 
    if (isFatal(QtWarningMsg))
        qt_message_fatal(QtWarningMsg, ctxt, message);
}
 
#ifndef QT_NO_DEBUG_STREAM
QDebug QMessageLogger::warning() const
{
    QDebug dbg = QDebug(QtWarningMsg);
    QMessageLogContext &ctxt = dbg.stream->context;
    ctxt.copyContextFrom(context);
    return dbg;
}
 
QDebug QMessageLogger::warning(const QLoggingCategory &cat) const
{
    QDebug dbg = QDebug(QtWarningMsg);
    if (!cat.isWarningEnabled())
        dbg.stream->message_output = false;
 
    QMessageLogContext &ctxt = dbg.stream->context;
    ctxt.copyContextFrom(context);
    ctxt.category = cat.categoryName();
 
    return dbg;
}
 
QDebug QMessageLogger::warning(QMessageLogger::CategoryFunction catFunc) const
{
    return warning((*catFunc)());
}
 
#endif
 
#undef qCritical
 
void QMessageLogger::critical(const char *msg, ...) const
{
    va_list ap;
    va_start(ap, msg); // use variable arg list
    const QString message = qt_message(QtCriticalMsg, context, msg, ap);
    va_end(ap);
 
    if (isFatal(QtCriticalMsg))
        qt_message_fatal(QtCriticalMsg, context, message);
}
 
void QMessageLogger::critical(const QLoggingCategory &cat, const char *msg, ...) const
{
    if (!cat.isCriticalEnabled())
        return;
 
    QMessageLogContext ctxt;
    ctxt.copyContextFrom(context);
    ctxt.category = cat.categoryName();
 
    va_list ap;
    va_start(ap, msg); // use variable arg list
    const QString message = qt_message(QtCriticalMsg, ctxt, msg, ap);
    va_end(ap);
 
    if (isFatal(QtCriticalMsg))
        qt_message_fatal(QtCriticalMsg, ctxt, message);
}
 
void QMessageLogger::critical(QMessageLogger::CategoryFunction catFunc,
                              const char *msg, ...) const
{
    const QLoggingCategory &cat = (*catFunc)();
    if (!cat.isCriticalEnabled())
        return;
 
    QMessageLogContext ctxt;
    ctxt.copyContextFrom(context);
    ctxt.category = cat.categoryName();
 
    va_list ap;
    va_start(ap, msg); // use variable arg list
    const QString message = qt_message(QtCriticalMsg, ctxt, msg, ap);
    va_end(ap);
 
    if (isFatal(QtCriticalMsg))
        qt_message_fatal(QtCriticalMsg, ctxt, message);
}
 
#ifndef QT_NO_DEBUG_STREAM
QDebug QMessageLogger::critical() const
{
    QDebug dbg = QDebug(QtCriticalMsg);
    QMessageLogContext &ctxt = dbg.stream->context;
    ctxt.copyContextFrom(context);
    return dbg;
}
 
QDebug QMessageLogger::critical(const QLoggingCategory &cat) const
{
    QDebug dbg = QDebug(QtCriticalMsg);
    if (!cat.isCriticalEnabled())
        dbg.stream->message_output = false;
 
    QMessageLogContext &ctxt = dbg.stream->context;
    ctxt.copyContextFrom(context);
    ctxt.category = cat.categoryName();
 
    return dbg;
}
 
QDebug QMessageLogger::critical(QMessageLogger::CategoryFunction catFunc) const
{
    return critical((*catFunc)());
}
 
#endif
 
#undef qFatal
 
void QMessageLogger::fatal(const QLoggingCategory &cat, const char *msg, ...) const noexcept
{
    QMessageLogContext ctxt;
    ctxt.copyContextFrom(context);
    ctxt.category = cat.categoryName();
 
    QString message;
 
    va_list ap;
    va_start(ap, msg); // use variable arg list
    QT_TERMINATE_ON_EXCEPTION(message = qt_message(QtFatalMsg, ctxt, msg, ap));
    va_end(ap);
 
    qt_message_fatal(QtCriticalMsg, ctxt, message);
}
 
void QMessageLogger::fatal(QMessageLogger::CategoryFunction catFunc,
                           const char *msg, ...) const noexcept
{
    const QLoggingCategory &cat = (*catFunc)();
 
    QMessageLogContext ctxt;
    ctxt.copyContextFrom(context);
    ctxt.category = cat.categoryName();
 
    QString message;
 
    va_list ap;
    va_start(ap, msg); // use variable arg list
    QT_TERMINATE_ON_EXCEPTION(message = qt_message(QtFatalMsg, ctxt, msg, ap));
    va_end(ap);
 
    qt_message_fatal(QtFatalMsg, ctxt, message);
}
 
void QMessageLogger::fatal(const char *msg, ...) const noexcept
{
    QString message;
 
    va_list ap;
    va_start(ap, msg); // use variable arg list
    QT_TERMINATE_ON_EXCEPTION(message = qt_message(QtFatalMsg, context, msg, ap));
    va_end(ap);
 
    qt_message_fatal(QtFatalMsg, context, message);
}
 
#ifndef QT_NO_DEBUG_STREAM
QDebug QMessageLogger::fatal() const
{
    QDebug dbg = QDebug(QtFatalMsg);
    QMessageLogContext &ctxt = dbg.stream->context;
    ctxt.copyContextFrom(context);
    return dbg;
}
 
QDebug QMessageLogger::fatal(const QLoggingCategory &cat) const
{
    QDebug dbg = QDebug(QtFatalMsg);
 
    QMessageLogContext &ctxt = dbg.stream->context;
    ctxt.copyContextFrom(context);
    ctxt.category = cat.categoryName();
 
    return dbg;
}
 
QDebug QMessageLogger::fatal(QMessageLogger::CategoryFunction catFunc) const
{
    return fatal((*catFunc)());
}
#endif // QT_NO_DEBUG_STREAM
 
Q_AUTOTEST_EXPORT QByteArray qCleanupFuncinfo(QByteArray info)
{
    // Strip the function info down to the base function name
    // note that this throws away the template definitions,
    // the parameter types (overloads) and any const/volatile qualifiers.
 
    if (info.isEmpty())
        return info;
 
    qsizetype pos;
 
    // Skip trailing [with XXX] for templates (gcc), but make
    // sure to not affect Objective-C message names.
    pos = info.size() - 1;
    if (info.endsWith(']') && !(info.startsWith('+') || info.startsWith('-'))) {
        while (--pos) {
          if (info.at(pos) == '[') {
              info.truncate(pos);
              break;
          }
        }
        if (info.endsWith(' ')) {
          info.chop(1);
        }
    }
 
    // operator names with '(', ')', '<', '>' in it
    static const char operator_call[] = "operator()";
    static const char operator_lessThan[] = "operator<";
    static const char operator_greaterThan[] = "operator>";
    static const char operator_lessThanEqual[] = "operator<=";
    static const char operator_greaterThanEqual[] = "operator>=";
 
    // canonize operator names
    info.replace("operator ", "operator");
 
    pos = -1;
    // remove argument list
    forever {
        int parencount = 0;
        pos = info.lastIndexOf(')', pos);
        if (pos == -1) {
            // Don't know how to parse this function name
            return info;
        }
        if (info.indexOf('>', pos) != -1
                || info.indexOf(':', pos) != -1) {
            // that wasn't the function argument list.
            --pos;
            continue;
        }
 
        // find the beginning of the argument list
        --pos;
        ++parencount;
        while (pos && parencount) {
            if (info.at(pos) == ')')
                ++parencount;
            else if (info.at(pos) == '(')
                --parencount;
            --pos;
        }
        if (parencount != 0)
            return info;
 
        info.truncate(++pos);
 
        if (info.at(pos - 1) == ')') {
            if (info.indexOf(operator_call) == pos - qsizetype(strlen(operator_call)))
                break;
 
            // this function returns a pointer to a function
            // and we matched the arguments of the return type's parameter list
            // try again
            info.remove(0, info.indexOf('('));
            info.chop(1);
            continue;
        } else {
            break;
        }
    }
 
    // find the beginning of the function name
    int parencount = 0;
    int templatecount = 0;
    --pos;
 
    // make sure special characters in operator names are kept
    if (pos > -1) {
        switch (info.at(pos)) {
        case ')':
            if (info.indexOf(operator_call) == pos - qsizetype(strlen(operator_call)) + 1)
                pos -= 2;
            break;
        case '<':
            if (info.indexOf(operator_lessThan) == pos - qsizetype(strlen(operator_lessThan)) + 1)
                --pos;
            break;
        case '>':
            if (info.indexOf(operator_greaterThan) == pos - qsizetype(strlen(operator_greaterThan)) + 1)
                --pos;
            break;
        case '=': {
            auto operatorLength = qsizetype(strlen(operator_lessThanEqual));
            if (info.indexOf(operator_lessThanEqual) == pos - operatorLength + 1)
                pos -= 2;
            else if (info.indexOf(operator_greaterThanEqual) == pos - operatorLength + 1)
                pos -= 2;
            break;
        }
        default:
            break;
        }
    }
 
    while (pos > -1) {
        if (parencount < 0 || templatecount < 0)
            return info;
 
        char c = info.at(pos);
        if (c == ')')
            ++parencount;
        else if (c == '(')
            --parencount;
        else if (c == '>')
            ++templatecount;
        else if (c == '<')
            --templatecount;
        else if (c == ' ' && templatecount == 0 && parencount == 0)
            break;
 
        --pos;
    }
    info = info.mid(pos + 1);
 
    // remove trailing '*', '&' that are part of the return argument
    while ((info.at(0) == '*')
           || (info.at(0) == '&'))
        info = info.mid(1);
 
    // we have the full function name now.
    // clean up the templates
    while ((pos = info.lastIndexOf('>')) != -1) {
        if (!info.contains('<'))
            break;
 
        // find the matching close
        qsizetype end = pos;
        templatecount = 1;
        --pos;
        while (pos && templatecount) {
            char c = info.at(pos);
            if (c == '>')
                ++templatecount;
            else if (c == '<')
                --templatecount;
            --pos;
        }
        ++pos;
        info.remove(pos, end - pos + 1);
    }
 
    return info;
}
 
// tokens as recognized in QT_MESSAGE_PATTERN
static const char categoryTokenC[] = "%{category}";
static const char typeTokenC[] = "%{type}";
static const char messageTokenC[] = "%{message}";
static const char fileTokenC[] = "%{file}";
static const char lineTokenC[] = "%{line}";
static const char functionTokenC[] = "%{function}";
static const char pidTokenC[] = "%{pid}";
static const char appnameTokenC[] = "%{appname}";
static const char threadidTokenC[] = "%{threadid}";
static const char qthreadptrTokenC[] = "%{qthreadptr}";
static const char timeTokenC[] = "%{time"; //not a typo: this command has arguments
static const char backtraceTokenC[] = "%{backtrace"; //ditto
static const char ifCategoryTokenC[] = "%{if-category}";
static const char ifDebugTokenC[] = "%{if-debug}";
static const char ifInfoTokenC[] = "%{if-info}";
static const char ifWarningTokenC[] = "%{if-warning}";
static const char ifCriticalTokenC[] = "%{if-critical}";
static const char ifFatalTokenC[] = "%{if-fatal}";
static const char endifTokenC[] = "%{endif}";
static const char emptyTokenC[] = "";
 
static const char defaultPattern[] = "%{if-category}%{category}: %{endif}%{message}";
 
struct QMessagePattern
{
    QMessagePattern();
    ~QMessagePattern();
 
    void setPattern(const QString &pattern);
 
    // 0 terminated arrays of literal tokens / literal or placeholder tokens
    std::unique_ptr<std::unique_ptr<const char[]>[]> literals;
    std::unique_ptr<const char *[]> tokens;
    QList<QString> timeArgs; // timeFormats in sequence of %{time
#ifndef QT_BOOTSTRAPPED
    QElapsedTimer timer;
#endif
#ifdef QLOGGING_HAVE_BACKTRACE
    struct BacktraceParams
    {
        QString backtraceSeparator;
        int backtraceDepth;
    };
    QList<BacktraceParams> backtraceArgs; // backtrace arguments in sequence of %{backtrace
#endif
 
    bool fromEnvironment;
    static QBasicMutex mutex;
};
#ifdef QLOGGING_HAVE_BACKTRACE
Q_DECLARE_TYPEINFO(QMessagePattern::BacktraceParams, Q_RELOCATABLE_TYPE);
#endif
 
Q_CONSTINIT QBasicMutex QMessagePattern::mutex;
 
QMessagePattern::QMessagePattern()
{
#ifndef QT_BOOTSTRAPPED
    timer.start();
#endif
    const QString envPattern = QString::fromLocal8Bit(qgetenv("QT_MESSAGE_PATTERN"));
    if (envPattern.isEmpty()) {
        setPattern(QLatin1StringView(defaultPattern));
        fromEnvironment = false;
    } else {
        setPattern(envPattern);
        fromEnvironment = true;
    }
}
 
QMessagePattern::~QMessagePattern() = default;
 
void QMessagePattern::setPattern(const QString &pattern)
{
    timeArgs.clear();
#ifdef QLOGGING_HAVE_BACKTRACE
    backtraceArgs.clear();
#endif
 
    // scanner
    QList<QString> lexemes;
    QString lexeme;
    bool inPlaceholder = false;
    for (int i = 0; i < pattern.size(); ++i) {
        const QChar c = pattern.at(i);
        if (c == u'%' && !inPlaceholder) {
            if ((i + 1 < pattern.size())
                    && pattern.at(i + 1) == u'{') {
                // beginning of placeholder
                if (!lexeme.isEmpty()) {
                    lexemes.append(lexeme);
                    lexeme.clear();
                }
                inPlaceholder = true;
            }
        }
 
        lexeme.append(c);
 
        if (c == u'}' && inPlaceholder) {
            // end of placeholder
            lexemes.append(lexeme);
            lexeme.clear();
            inPlaceholder = false;
        }
    }
    if (!lexeme.isEmpty())
        lexemes.append(lexeme);
 
    // tokenizer
    std::vector<std::unique_ptr<const char[]>> literalsVar;
    tokens.reset(new const char *[lexemes.size() + 1]);
    tokens[lexemes.size()] = nullptr;
 
    bool nestedIfError = false;
    bool inIf = false;
    QString error;
 
    for (int i = 0; i < lexemes.size(); ++i) {
        const QString lexeme = lexemes.at(i);
        if (lexeme.startsWith("%{"_L1) && lexeme.endsWith(u'}')) {
            // placeholder
            if (lexeme == QLatin1StringView(typeTokenC)) {
                tokens[i] = typeTokenC;
            } else if (lexeme == QLatin1StringView(categoryTokenC))
                tokens[i] = categoryTokenC;
            else if (lexeme == QLatin1StringView(messageTokenC))
                tokens[i] = messageTokenC;
            else if (lexeme == QLatin1StringView(fileTokenC))
                tokens[i] = fileTokenC;
            else if (lexeme == QLatin1StringView(lineTokenC))
                tokens[i] = lineTokenC;
            else if (lexeme == QLatin1StringView(functionTokenC))
                tokens[i] = functionTokenC;
            else if (lexeme == QLatin1StringView(pidTokenC))
                tokens[i] = pidTokenC;
            else if (lexeme == QLatin1StringView(appnameTokenC))
                tokens[i] = appnameTokenC;
            else if (lexeme == QLatin1StringView(threadidTokenC))
                tokens[i] = threadidTokenC;
            else if (lexeme == QLatin1StringView(qthreadptrTokenC))
                tokens[i] = qthreadptrTokenC;
            else if (lexeme.startsWith(QLatin1StringView(timeTokenC))) {
                tokens[i] = timeTokenC;
                qsizetype spaceIdx = lexeme.indexOf(QChar::fromLatin1(' '));
                if (spaceIdx > 0)
                    timeArgs.append(lexeme.mid(spaceIdx + 1, lexeme.size() - spaceIdx - 2));
                else
                    timeArgs.append(QString());
            } else if (lexeme.startsWith(QLatin1StringView(backtraceTokenC))) {
#ifdef QLOGGING_HAVE_BACKTRACE
                tokens[i] = backtraceTokenC;
                QString backtraceSeparator = QStringLiteral("|");
                int backtraceDepth = 5;
                static const QRegularExpression depthRx(QStringLiteral(" depth=(?|\"([^\"]*)\"|([^ }]*))"));
                static const QRegularExpression separatorRx(QStringLiteral(" separator=(?|\"([^\"]*)\"|([^ }]*))"));
                QRegularExpressionMatch m = depthRx.match(lexeme);
                if (m.hasMatch()) {
                    int depth = m.capturedView(1).toInt();
                    if (depth <= 0)
                        error += "QT_MESSAGE_PATTERN: %{backtrace} depth must be a number greater than 0\n"_L1;
                    else
                        backtraceDepth = depth;
                }
                m = separatorRx.match(lexeme);
                if (m.hasMatch())
                    backtraceSeparator = m.captured(1);
                BacktraceParams backtraceParams;
                backtraceParams.backtraceDepth = backtraceDepth;
                backtraceParams.backtraceSeparator = backtraceSeparator;
                backtraceArgs.append(backtraceParams);
#else
                error += "QT_MESSAGE_PATTERN: %{backtrace} is not supported by this Qt build\n"_L1;
                tokens[i] = "";
#endif
            }
 
#define IF_TOKEN(LEVEL) \
            else if (lexeme == QLatin1StringView(LEVEL)) { \
                if (inIf) \
                    nestedIfError = true; \
                tokens[i] = LEVEL; \
                inIf = true; \
            }
            IF_TOKEN(ifCategoryTokenC)
            IF_TOKEN(ifDebugTokenC)
            IF_TOKEN(ifInfoTokenC)
            IF_TOKEN(ifWarningTokenC)
            IF_TOKEN(ifCriticalTokenC)
            IF_TOKEN(ifFatalTokenC)
#undef IF_TOKEN
            else if (lexeme == QLatin1StringView(endifTokenC)) {
                tokens[i] = endifTokenC;
                if (!inIf && !nestedIfError)
                    error += "QT_MESSAGE_PATTERN: %{endif} without an %{if-*}\n"_L1;
                inIf = false;
            } else {
                tokens[i] = emptyTokenC;
                error += QStringLiteral("QT_MESSAGE_PATTERN: Unknown placeholder %1\n")
                        .arg(lexeme);
            }
        } else {
            using UP = std::unique_ptr<char[]>;
            tokens[i] = literalsVar.emplace_back(UP(qstrdup(lexeme.toLatin1().constData()))).get();
        }
    }
    if (nestedIfError)
        error += "QT_MESSAGE_PATTERN: %{if-*} cannot be nested\n"_L1;
    else if (inIf)
        error += "QT_MESSAGE_PATTERN: missing %{endif}\n"_L1;
 
    if (!error.isEmpty())
        qt_message_print(error);
 
    literals.reset(new std::unique_ptr<const char[]>[literalsVar.size() + 1]);
    std::move(literalsVar.begin(), literalsVar.end(), &literals[0]);
}
 
#if defined(QLOGGING_HAVE_BACKTRACE) && !defined(QT_BOOTSTRAPPED)
// make sure the function has "Message" in the name so the function is removed
/*
  A typical backtrace in debug mode looks like:
    #0  backtraceFramesForLogMessage (frameCount=5) at qlogging.cpp:1296
    #1  formatBacktraceForLogMessage (backtraceParams=..., function=0x4040b8 "virtual void MyClass::myFunction(int)") at qlogging.cpp:1344
    #2  qFormatLogMessage (type=QtDebugMsg, context=..., str=...) at qlogging.cpp:1452
    #3  stderr_message_handler (type=QtDebugMsg, context=..., message=...) at qlogging.cpp:1744
    #4  qDefaultMessageHandler (type=QtDebugMsg, context=..., message=...) at qlogging.cpp:1795
    #5  qt_message_print (msgType=QtDebugMsg, context=..., message=...) at qlogging.cpp:1840
    #6  qt_message_output (msgType=QtDebugMsg, context=..., message=...) at qlogging.cpp:1891
    #7  QDebug::~QDebug (this=<optimized out>, __in_chrg=<optimized out>) at qdebug.h:111
*/
static constexpr int TypicalBacktraceFrameCount = 8;
 
#  if defined(Q_CC_GNU) && !defined(Q_CC_CLANG)
// force skipping the frame pointer, to save the backtrace() function some work
#    pragma GCC push_options
#    pragma GCC optimize ("omit-frame-pointer")
#  endif
 
static QStringList backtraceFramesForLogMessage(int frameCount)
{
    struct DecodedFrame {
        QString library;
        QString function;
    };
 
    QStringList result;
    if (frameCount == 0)
        return result;
 
    QVarLengthArray<void *, 32> buffer(TypicalBacktraceFrameCount + frameCount);
    int n = backtrace(buffer.data(), buffer.size());
    if (n <= 0)
        return result;
    buffer.resize(n);
 
    auto shouldSkipFrame = [&result](const auto &library, const auto &function) {
        if (!result.isEmpty() || !library.contains("Qt6Core"_L1))
            return false;
        if (function.isEmpty())
            return true;
        if (function.contains("6QDebug"_L1))
            return true;
        if (function.contains("Message"_L1) || function.contains("_message"_L1))
            return true;
        return false;
    };
 
    auto demangled = [](auto &function) -> QString {
        if (!function.startsWith("_Z"_L1))
            return function;
 
        // we optimize for the case where __cxa_demangle succeeds
        auto fn = [&]() {
            if constexpr (sizeof(function.at(0)) == 1)
                return function.data();                 // -> const char *
            else
                return std::move(function).toUtf8();    // -> QByteArray
        }();
        QScopedPointer<char, QScopedPointerPodDeleter> demangled;
        demangled.reset(abi::__cxa_demangle(fn, nullptr, nullptr, nullptr));
 
        if (demangled)
            return QString::fromUtf8(qCleanupFuncinfo(demangled.data()));
        else
            return QString::fromUtf8(fn);       // restore
    };
 
#  if QT_CONFIG(dladdr)
    // use dladdr() instead of backtrace_symbols()
    QString cachedLibrary;
    const char *cachedFname = nullptr;
    auto decodeFrame = [&](void *addr) -> DecodedFrame {
        Dl_info info;
        if (!dladdr(addr, &info))
            return {};
 
        // These are actually UTF-8, so we'll correct below
        QLatin1StringView fn(info.dli_sname);
        QLatin1StringView lib;
        if (const char *lastSlash = strrchr(info.dli_fname, '/'))
            lib = QLatin1StringView(lastSlash + 1);
        else
            lib = QLatin1StringView(info.dli_fname);
 
        if (shouldSkipFrame(lib, fn))
            return {};
 
        QString function = demangled(fn);
        if (lib.data() != cachedFname) {
            cachedFname = lib.data();
            cachedLibrary = QString::fromUtf8(cachedFname, lib.size());
        }
        return { cachedLibrary, function };
    };
#  else
    // The results of backtrace_symbols looks like this:
    //    /lib/libc.so.6(__libc_start_main+0xf3) [0x4a937413]
    // The offset and function name are optional.
    // This regexp tries to extract the library name (without the path) and the function name.
    // This code is protected by QMessagePattern::mutex so it is thread safe on all compilers
    static const QRegularExpression rx(QStringLiteral("^(?:[^(]*/)?([^(/]+)\\(([^+]*)(?:[\\+[a-f0-9x]*)?\\) \\[[a-f0-9x]*\\]$"));
 
    auto decodeFrame = [&](void *&addr) -> DecodedFrame {
        QScopedPointer<char*, QScopedPointerPodDeleter> strings(backtrace_symbols(&addr, 1));
        QString trace = QString::fromUtf8(strings.data()[0]);
        QRegularExpressionMatch m = rx.match(trace);
        if (!m.hasMatch())
            return {};
 
        QString library = m.captured(1);
        QString function = m.captured(2);
 
        // skip the trace from QtCore that are because of the qDebug itself
        if (shouldSkipFrame(library, function))
            return {};
 
        function = demangled(function);
        return { library, function };
    };
#  endif
 
    for (void *&addr : buffer) {
        DecodedFrame frame = decodeFrame(addr);
        if (!frame.library.isEmpty()) {
            if (frame.function.isEmpty())
                result.append(u'?' + frame.library + u'?');
            else
                result.append(frame.function);
        } else {
            // innermost, unknown frames are usually the logging framework itself
            if (!result.isEmpty())
                result.append(QStringLiteral("???"));
        }
 
        if (result.size() == frameCount)
            break;
    }
    return result;
}
 
static QString formatBacktraceForLogMessage(const QMessagePattern::BacktraceParams backtraceParams,
                                            const char *function)
{
    QString backtraceSeparator = backtraceParams.backtraceSeparator;
    int backtraceDepth = backtraceParams.backtraceDepth;
 
    QStringList frames = backtraceFramesForLogMessage(backtraceDepth);
    if (frames.isEmpty())
        return QString();
 
    // if the first frame is unknown, replace it with the context function
    if (function && frames.at(0).startsWith(u'?'))
        frames[0] = QString::fromUtf8(qCleanupFuncinfo(function));
 
    return frames.join(backtraceSeparator);
}
 
#  if defined(Q_CC_GNU) && !defined(Q_CC_CLANG)
#    pragma GCC pop_options
#  endif
#endif // QLOGGING_HAVE_BACKTRACE && !QT_BOOTSTRAPPED
 
Q_GLOBAL_STATIC(QMessagePattern, qMessagePattern)
 
 
QString qFormatLogMessage(QtMsgType type, const QMessageLogContext &context, const QString &str)
{
    QString message;
 
    const auto locker = qt_scoped_lock(QMessagePattern::mutex);
 
    QMessagePattern *pattern = qMessagePattern();
    if (!pattern) {
        // after destruction of static QMessagePattern instance
        message.append(str);
        return message;
    }
 
    bool skip = false;
 
#ifndef QT_BOOTSTRAPPED
    int timeArgsIdx = 0;
#ifdef QLOGGING_HAVE_BACKTRACE
    int backtraceArgsIdx = 0;
#endif
#endif
 
    // we do not convert file, function, line literals to local encoding due to overhead
    for (int i = 0; pattern->tokens[i]; ++i) {
        const char *token = pattern->tokens[i];
        if (token == endifTokenC) {
            skip = false;
        } else if (skip) {
            // we skip adding messages, but we have to iterate over
            // timeArgsIdx and backtraceArgsIdx anyway
#ifndef QT_BOOTSTRAPPED
            if (token == timeTokenC)
                timeArgsIdx++;
#ifdef QLOGGING_HAVE_BACKTRACE
            else if (token == backtraceTokenC)
                backtraceArgsIdx++;
#endif
#endif
        } else if (token == messageTokenC) {
            message.append(str);
        } else if (token == categoryTokenC) {
#ifndef Q_OS_ANDROID
            // Don't add the category to the message on Android
            message.append(QLatin1StringView(context.category));
#endif
        } else if (token == typeTokenC) {
            switch (type) {
            case QtDebugMsg:   message.append("debug"_L1); break;
            case QtInfoMsg:    message.append("info"_L1); break;
            case QtWarningMsg: message.append("warning"_L1); break;
            case QtCriticalMsg:message.append("critical"_L1); break;
            case QtFatalMsg:   message.append("fatal"_L1); break;
            }
        } else if (token == fileTokenC) {
            if (context.file)
                message.append(QLatin1StringView(context.file));
            else
                message.append("unknown"_L1);
        } else if (token == lineTokenC) {
            message.append(QString::number(context.line));
        } else if (token == functionTokenC) {
            if (context.function)
                message.append(QString::fromLatin1(qCleanupFuncinfo(context.function)));
            else
                message.append("unknown"_L1);
#ifndef QT_BOOTSTRAPPED
        } else if (token == pidTokenC) {
            message.append(QString::number(QCoreApplication::applicationPid()));
        } else if (token == appnameTokenC) {
            message.append(QCoreApplication::applicationName());
        } else if (token == threadidTokenC) {
            // print the TID as decimal
            message.append(QString::number(qt_gettid()));
        } else if (token == qthreadptrTokenC) {
            message.append("0x"_L1);
            message.append(QString::number(qlonglong(QThread::currentThread()->currentThread()), 16));
#ifdef QLOGGING_HAVE_BACKTRACE
        } else if (token == backtraceTokenC) {
            QMessagePattern::BacktraceParams backtraceParams = pattern->backtraceArgs.at(backtraceArgsIdx);
            backtraceArgsIdx++;
            message.append(formatBacktraceForLogMessage(backtraceParams, context.function));
#endif
        } else if (token == timeTokenC) {
            QString timeFormat = pattern->timeArgs.at(timeArgsIdx);
            timeArgsIdx++;
            if (timeFormat == "process"_L1) {
                quint64 ms = pattern->timer.elapsed();
                message.append(QString::asprintf("%6d.%03d", uint(ms / 1000), uint(ms % 1000)));
            } else if (timeFormat == "boot"_L1) {
                // just print the milliseconds since the elapsed timer reference
                // like the Linux kernel does
                qint64 ms = QDeadlineTimer::current().deadline();
                message.append(QString::asprintf("%6d.%03d", uint(ms / 1000), uint(ms % 1000)));
#if QT_CONFIG(datestring)
            } else if (timeFormat.isEmpty()) {
                    message.append(QDateTime::currentDateTime().toString(Qt::ISODate));
            } else {
                message.append(QDateTime::currentDateTime().toString(timeFormat));
#endif // QT_CONFIG(datestring)
            }
#endif // !QT_BOOTSTRAPPED
        } else if (token == ifCategoryTokenC) {
            if (isDefaultCategory(context.category))
                skip = true;
#define HANDLE_IF_TOKEN(LEVEL)  \
        } else if (token == if##LEVEL##TokenC) { \
            skip = type != Qt##LEVEL##Msg;
        HANDLE_IF_TOKEN(Debug)
        HANDLE_IF_TOKEN(Info)
        HANDLE_IF_TOKEN(Warning)
        HANDLE_IF_TOKEN(Critical)
        HANDLE_IF_TOKEN(Fatal)
#undef HANDLE_IF_TOKEN
        } else {
            message.append(QLatin1StringView(token));
        }
    }
    return message;
}
 
static void qDefaultMessageHandler(QtMsgType type, const QMessageLogContext &context, const QString &buf);
 
// pointer to QtMessageHandler debug handler (with context)
Q_CONSTINIT static QBasicAtomicPointer<void (QtMsgType, const QMessageLogContext &, const QString &)> messageHandler = Q_BASIC_ATOMIC_INITIALIZER(nullptr);
 
// ------------------------ Alternate logging sinks -------------------------
 
#if defined(QT_BOOTSTRAPPED)
    // Bootstrapped tools always print to stderr, so no need for alternate sinks
#else
 
#if QT_CONFIG(slog2)
#ifndef QT_LOG_CODE
#define QT_LOG_CODE 9000
#endif
 
static bool slog2_default_handler(QtMsgType type, const QMessageLogContext &context, const QString &message)
{
    if (shouldLogToStderr())
        return false; // Leave logging up to stderr handler
 
    QString formattedMessage = qFormatLogMessage(type, context, message);
    formattedMessage.append(u'\n');
    if (slog2_set_default_buffer((slog2_buffer_t)-1) == 0) {
        slog2_buffer_set_config_t buffer_config;
        slog2_buffer_t buffer_handle;
 
        buffer_config.buffer_set_name = __progname;
        buffer_config.num_buffers = 1;
        buffer_config.verbosity_level = SLOG2_DEBUG1;
        buffer_config.buffer_config[0].buffer_name = "default";
        buffer_config.buffer_config[0].num_pages = 8;
 
        if (slog2_register(&buffer_config, &buffer_handle, 0) == -1) {
            fprintf(stderr, "Error registering slogger2 buffer!\n");
            fprintf(stderr, "%s", formattedMessage.toLocal8Bit().constData());
            fflush(stderr);
            return false;
        }
 
        // Set as the default buffer
        slog2_set_default_buffer(buffer_handle);
    }
    int severity = SLOG2_INFO;
    //Determines the severity level
    switch (type) {
    case QtDebugMsg:
        severity = SLOG2_DEBUG1;
        break;
    case QtInfoMsg:
        severity = SLOG2_INFO;
        break;
    case QtWarningMsg:
        severity = SLOG2_NOTICE;
        break;
    case QtCriticalMsg:
        severity = SLOG2_WARNING;
        break;
    case QtFatalMsg:
        severity = SLOG2_ERROR;
        break;
    }
    //writes to the slog2 buffer
    slog2c(NULL, QT_LOG_CODE, severity, formattedMessage.toLocal8Bit().constData());
 
    return true; // Prevent further output to stderr
}
#endif // slog2
 
#if QT_CONFIG(journald)
static bool systemd_default_message_handler(QtMsgType type,
                                            const QMessageLogContext &context,
                                            const QString &message)
{
    if (shouldLogToStderr())
        return false; // Leave logging up to stderr handler
 
    QString formattedMessage = qFormatLogMessage(type, context, message);
 
    int priority = LOG_INFO; // Informational
    switch (type) {
    case QtDebugMsg:
        priority = LOG_DEBUG; // Debug-level messages
        break;
    case QtInfoMsg:
        priority = LOG_INFO; // Informational conditions
        break;
    case QtWarningMsg:
        priority = LOG_WARNING; // Warning conditions
        break;
    case QtCriticalMsg:
        priority = LOG_CRIT; // Critical conditions
        break;
    case QtFatalMsg:
        priority = LOG_ALERT; // Action must be taken immediately
        break;
    }
 
    sd_journal_send("MESSAGE=%s",     formattedMessage.toUtf8().constData(),
                    "PRIORITY=%i",    priority,
                    "CODE_FUNC=%s",   context.function ? context.function : "unknown",
                    "CODE_LINE=%d",   context.line,
                    "CODE_FILE=%s",   context.file ? context.file : "unknown",
                    "QT_CATEGORY=%s", context.category ? context.category : "unknown",
                    NULL);
 
    return true; // Prevent further output to stderr
}
#endif
 
#if QT_CONFIG(syslog)
static bool syslog_default_message_handler(QtMsgType type, const QMessageLogContext &context, const QString &message)
{
    if (shouldLogToStderr())
        return false; // Leave logging up to stderr handler
 
    QString formattedMessage = qFormatLogMessage(type, context, message);
 
    int priority = LOG_INFO; // Informational
    switch (type) {
    case QtDebugMsg:
        priority = LOG_DEBUG; // Debug-level messages
        break;
    case QtInfoMsg:
        priority = LOG_INFO; // Informational conditions
        break;
    case QtWarningMsg:
        priority = LOG_WARNING; // Warning conditions
        break;
    case QtCriticalMsg:
        priority = LOG_CRIT; // Critical conditions
        break;
    case QtFatalMsg:
        priority = LOG_ALERT; // Action must be taken immediately
        break;
    }
 
    syslog(priority, "%s", formattedMessage.toUtf8().constData());
 
    return true; // Prevent further output to stderr
}
#endif
 
#ifdef Q_OS_ANDROID
static bool android_default_message_handler(QtMsgType type,
                                  const QMessageLogContext &context,
                                  const QString &message)
{
    if (shouldLogToStderr())
        return false; // Leave logging up to stderr handler
 
    QString formattedMessage = qFormatLogMessage(type, context, message);
 
    android_LogPriority priority = ANDROID_LOG_DEBUG;
    switch (type) {
    case QtDebugMsg:
        priority = ANDROID_LOG_DEBUG;
        break;
    case QtInfoMsg:
        priority = ANDROID_LOG_INFO;
        break;
    case QtWarningMsg:
        priority = ANDROID_LOG_WARN;
        break;
    case QtCriticalMsg:
        priority = ANDROID_LOG_ERROR;
        break;
    case QtFatalMsg:
        priority = ANDROID_LOG_FATAL;
        break;
    };
 
    // If application name is a tag ensure it has no spaces
    // If a category is defined, use it as an Android logging tag
    __android_log_print(priority, isDefaultCategory(context.category) ?
                        qPrintable(QCoreApplication::applicationName().replace(u' ', u'_')) : context.category,
                        "%s\n", qPrintable(formattedMessage));
 
    return true; // Prevent further output to stderr
}
#endif //Q_OS_ANDROID
 
#ifdef Q_OS_WIN
static void win_outputDebugString_helper(const QString &message)
{
    const qsizetype maxOutputStringLength = 32766;
    Q_CONSTINIT static QBasicMutex m;
    auto locker = qt_unique_lock(m);
    // fast path: Avoid string copies if one output is enough
    if (message.length() <= maxOutputStringLength) {
        OutputDebugString(reinterpret_cast<const wchar_t *>(message.utf16()));
    } else {
        wchar_t *messagePart = new wchar_t[maxOutputStringLength + 1];
        for (qsizetype i = 0; i < message.length(); i += maxOutputStringLength) {
            const qsizetype length = qMin(message.length() - i, maxOutputStringLength);
            const qsizetype len = QStringView{message}.mid(i, length).toWCharArray(messagePart);
            Q_ASSERT(len == length);
            messagePart[len] = 0;
            OutputDebugString(messagePart);
        }
        delete[] messagePart;
    }
}
 
static bool win_message_handler(QtMsgType type, const QMessageLogContext &context, const QString &message)
{
    if (shouldLogToStderr())
        return false; // Leave logging up to stderr handler
 
    const QString formattedMessage = qFormatLogMessage(type, context, message).append(u'\n');
    win_outputDebugString_helper(formattedMessage);
 
    return true; // Prevent further output to stderr
}
#endif
 
#ifdef Q_OS_WASM
static bool wasm_default_message_handler(QtMsgType type,
                                  const QMessageLogContext &context,
                                  const QString &message)
{
    if (shouldLogToStderr())
        return false; // Leave logging up to stderr handler
 
    QString formattedMessage = qFormatLogMessage(type, context, message);
    int emOutputFlags = (EM_LOG_CONSOLE | EM_LOG_DEMANGLE);
    QByteArray localMsg = message.toLocal8Bit();
    switch (type) {
    case QtDebugMsg:
        break;
    case QtInfoMsg:
        break;
    case QtWarningMsg:
        emOutputFlags |= EM_LOG_WARN;
        break;
    case QtCriticalMsg:
        emOutputFlags |= EM_LOG_ERROR;
        break;
    case QtFatalMsg:
        emOutputFlags |= EM_LOG_ERROR;
    }
    emscripten_log(emOutputFlags, "%s\n", qPrintable(formattedMessage));
 
    return true; // Prevent further output to stderr
}
#endif
 
#endif // Bootstrap check
 
// --------------------------------------------------------------------------
 
static void stderr_message_handler(QtMsgType type, const QMessageLogContext &context, const QString &message)
{
    QString formattedMessage = qFormatLogMessage(type, context, message);
 
    // print nothing if message pattern didn't apply / was empty.
    // (still print empty lines, e.g. because message itself was empty)
    if (formattedMessage.isNull())
        return;
 
    fprintf(stderr, "%s\n", formattedMessage.toLocal8Bit().constData());
    fflush(stderr);
}
 
static void qDefaultMessageHandler(QtMsgType type, const QMessageLogContext &context,
                                   const QString &message)
{
    bool handledStderr = false;
 
    // A message sink logs the message to a structured or unstructured destination,
    // optionally formatting the message if the latter, and returns true if the sink
    // handled stderr output as well, which will shortcut our default stderr output.
    // In the future, if we allow multiple/dynamic sinks, this will be iterating
    // a list of sinks.
 
#if !defined(QT_BOOTSTRAPPED)
# if defined(Q_OS_WIN)
    handledStderr |= win_message_handler(type, context, message);
# elif QT_CONFIG(slog2)
    handledStderr |= slog2_default_handler(type, context, message);
# elif QT_CONFIG(journald)
    handledStderr |= systemd_default_message_handler(type, context, message);
# elif QT_CONFIG(syslog)
    handledStderr |= syslog_default_message_handler(type, context, message);
# elif defined(Q_OS_ANDROID)
    handledStderr |= android_default_message_handler(type, context, message);
# elif defined(QT_USE_APPLE_UNIFIED_LOGGING)
    handledStderr |= AppleUnifiedLogger::messageHandler(type, context, message);
# elif defined Q_OS_WASM
    handledStderr |= wasm_default_message_handler(type, context, message);
# endif
#endif
 
    if (!handledStderr)
        stderr_message_handler(type, context, message);
}
 
#if defined(Q_COMPILER_THREAD_LOCAL)
 
Q_CONSTINIT static thread_local bool msgHandlerGrabbed = false;
 
static bool grabMessageHandler()
{
    if (msgHandlerGrabbed)
        return false;
 
    msgHandlerGrabbed = true;
    return true;
}
 
static void ungrabMessageHandler()
{
    msgHandlerGrabbed = false;
}
 
#else
static bool grabMessageHandler() { return true; }
static void ungrabMessageHandler() { }
#endif // (Q_COMPILER_THREAD_LOCAL)
 
static void qt_message_print(QtMsgType msgType, const QMessageLogContext &context, const QString &message)
{
#ifndef QT_BOOTSTRAPPED
    Q_TRACE(qt_message_print, msgType, context.category, context.function, context.file, context.line, message);
 
    // qDebug, qWarning, ... macros do not check whether category is enabledgc
    if (msgType != QtFatalMsg && isDefaultCategory(context.category)) {
        if (QLoggingCategory *defaultCategory = QLoggingCategory::defaultCategory()) {
            if (!defaultCategory->isEnabled(msgType))
                return;
        }
    }
#endif
 
    // prevent recursion in case the message handler generates messages
    // itself, e.g. by using Qt API
    if (grabMessageHandler()) {
        const auto ungrab = qScopeGuard([]{ ungrabMessageHandler(); });
        auto msgHandler = messageHandler.loadAcquire();
        (msgHandler ? msgHandler : qDefaultMessageHandler)(msgType, context, message);
    } else {
        fprintf(stderr, "%s\n", message.toLocal8Bit().constData());
    }
}
 
static void qt_message_print(const QString &message)
{
#if defined(Q_OS_WIN) && !defined(QT_BOOTSTRAPPED)
    if (!shouldLogToStderr()) {
        win_outputDebugString_helper(message);
        return;
    }
#endif
    fprintf(stderr, "%s", message.toLocal8Bit().constData());
    fflush(stderr);
}
 
static void qt_message_fatal(QtMsgType, const QMessageLogContext &context, const QString &message)
{
#if defined(Q_CC_MSVC_ONLY) && defined(QT_DEBUG) && defined(_DEBUG) && defined(_CRT_ERROR)
    wchar_t contextFileL[256];
    // we probably should let the compiler do this for us, by declaring QMessageLogContext::file to
    // be const wchar_t * in the first place, but the #ifdefery above is very complex  and we
    // wouldn't be able to change it later on...
    convert_to_wchar_t_elided(contextFileL, sizeof contextFileL / sizeof *contextFileL,
                              context.file);
    // get the current report mode
    int reportMode = _CrtSetReportMode(_CRT_ERROR, _CRTDBG_MODE_WNDW);
    _CrtSetReportMode(_CRT_ERROR, reportMode);
 
    int ret = _CrtDbgReportW(_CRT_ERROR, contextFileL, context.line, _CRT_WIDE(QT_VERSION_STR),
                             reinterpret_cast<const wchar_t *>(message.utf16()));
    if ((ret == 0) && (reportMode & _CRTDBG_MODE_WNDW))
        return; // ignore
    else if (ret == 1)
        _CrtDbgBreak();
#else
    Q_UNUSED(context);
    Q_UNUSED(message);
#endif
 
    qAbort();
}
 
 
void qt_message_output(QtMsgType msgType, const QMessageLogContext &context, const QString &message)
{
    qt_message_print(msgType, context, message);
    if (isFatal(msgType))
        qt_message_fatal(msgType, context, message);
}
 
void qErrnoWarning(const char *msg, ...)
{
    // qt_error_string() will allocate anyway, so we don't have
    // to be careful here (like we do in plain qWarning())
    QString error_string = qt_error_string(-1);  // before vasprintf changes errno/GetLastError()
 
    va_list ap;
    va_start(ap, msg);
    QString buf = QString::vasprintf(msg, ap);
    va_end(ap);
 
    buf += " ("_L1 + error_string + u')';
    QMessageLogContext context;
    qt_message_output(QtCriticalMsg, context, buf);
}
 
void qErrnoWarning(int code, const char *msg, ...)
{
    // qt_error_string() will allocate anyway, so we don't have
    // to be careful here (like we do in plain qWarning())
    va_list ap;
    va_start(ap, msg);
    QString buf = QString::vasprintf(msg, ap);
    va_end(ap);
 
    buf += " ("_L1 + qt_error_string(code) + u')';
    QMessageLogContext context;
    qt_message_output(QtCriticalMsg, context, buf);
}
 
QtMessageHandler qInstallMessageHandler(QtMessageHandler h)
{
    const auto old = messageHandler.fetchAndStoreOrdered(h);
    if (old)
        return old;
    else
        return qDefaultMessageHandler;
}
 
void qSetMessagePattern(const QString &pattern)
{
    const auto locker = qt_scoped_lock(QMessagePattern::mutex);
 
    if (!qMessagePattern()->fromEnvironment)
        qMessagePattern()->setPattern(pattern);
}
 
 
QMessageLogContext &QMessageLogContext::copyContextFrom(const QMessageLogContext &logContext) noexcept
{
    this->category = logContext.category;
    this->file = logContext.file;
    this->line = logContext.line;
    this->function = logContext.function;
    return *this;
}
 
QT_END_NAMESPACE