qcoreapplication.cpp

Go to the documentation of this file.

// Copyright (C) 2021 The Qt Company Ltd.
// Copyright (C) 2021 Intel Corporation.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
#include "qcoreapplication.h"
#include "qcoreapplication_p.h"
 
#ifndef QT_NO_QOBJECT
#include "qabstracteventdispatcher.h"
#include "qcoreevent.h"
#include "qcoreevent_p.h"
#include "qeventloop.h"
#endif
#include "qmetaobject.h"
#include <private/qproperty_p.h>
#include "qcorecmdlineargs_p.h"
#include <qdatastream.h>
#include <qdebug.h>
#include <qdir.h>
#include <qfile.h>
#include <qfileinfo.h>
#include <qmutex.h>
#include <private/qloggingregistry_p.h>
#include <qscopeguard.h>
#include <qstandardpaths.h>
#ifndef QT_NO_QOBJECT
#include <qthread.h>
#include <qthreadstorage.h>
#if QT_CONFIG(future)
#include <QtCore/qpromise.h>
#endif
#include <private/qthread_p.h>
#if QT_CONFIG(thread)
#include <qthreadpool.h>
#include <private/qthreadpool_p.h>
#endif
#endif
#include <qlibraryinfo.h>
#include <qvarlengtharray.h>
#include <private/qfactoryloader_p.h>
#include <private/qfunctions_p.h>
#include <private/qlocale_p.h>
#include <private/qlocking_p.h>
#include <private/qhooks_p.h>
 
#if QT_CONFIG(permissions)
#include <private/qpermissions_p.h>
#endif
 
#ifndef QT_NO_QOBJECT
#if defined(Q_OS_UNIX)
# if defined(Q_OS_DARWIN)
#  include "qeventdispatcher_cf_p.h"
# else
#  if !defined(QT_NO_GLIB)
#   include "qeventdispatcher_glib_p.h"
#  endif
# endif
# include "qeventdispatcher_unix_p.h"
#endif
#ifdef Q_OS_WIN
#include "qeventdispatcher_win_p.h"
#endif
#endif // QT_NO_QOBJECT
 
#if defined(Q_OS_ANDROID)
#include <QtCore/qjniobject.h>
#endif
 
#ifdef Q_OS_DARWIN
#  include "qcore_mac_p.h"
#endif
 
#include <stdlib.h>
 
#ifdef Q_OS_UNIX
#  include <locale.h>
#  ifndef Q_OS_INTEGRITY
#    include <langinfo.h>
#  endif
#  include <unistd.h>
#  include <sys/types.h>
 
#  include "qcore_unix_p.h"
#endif
 
#if __has_include(<sys/auxv.h>)     // Linux and FreeBSD
#  include <sys/auxv.h>
#endif
 
#ifdef Q_OS_VXWORKS
#  include <taskLib.h>
#endif
 
#ifdef Q_OS_WASM
#include <emscripten/val.h>
#endif
 
#ifdef QT_BOOTSTRAPPED
#include <private/qtrace_p.h>
#else
#include <qtcore_tracepoints_p.h>
#endif
 
#include <algorithm>
#include <memory>
#include <string>
 
QT_BEGIN_NAMESPACE
 
using namespace Qt::StringLiterals;
 
Q_TRACE_PREFIX(qtcore,
   "#include <qcoreevent.h>"
);
Q_TRACE_METADATA(qtcore, "ENUM { AUTO, RANGE User ... MaxUser } QEvent::Type;");
Q_TRACE_POINT(qtcore, QCoreApplication_postEvent_entry, QObject *receiver, QEvent *event, QEvent::Type type);
Q_TRACE_POINT(qtcore, QCoreApplication_postEvent_exit);
Q_TRACE_POINT(qtcore, QCoreApplication_postEvent_event_compressed, QObject *receiver, QEvent *event);
Q_TRACE_POINT(qtcore, QCoreApplication_postEvent_event_posted, QObject *receiver, QEvent *event, QEvent::Type type);
Q_TRACE_POINT(qtcore, QCoreApplication_sendEvent, QObject *receiver, QEvent *event, QEvent::Type type);
Q_TRACE_POINT(qtcore, QCoreApplication_sendSpontaneousEvent, QObject *receiver, QEvent *event, QEvent::Type type);
Q_TRACE_POINT(qtcore, QCoreApplication_notify_entry, QObject *receiver, QEvent *event, QEvent::Type type);
Q_TRACE_POINT(qtcore, QCoreApplication_notify_exit, bool consumed, bool filtered);
 
#if defined(Q_OS_WIN) || defined(Q_OS_DARWIN)
extern QString qAppFileName();
#endif
 
Q_CONSTINIT bool QCoreApplicationPrivate::setuidAllowed = false;
 
#if !defined(Q_OS_WIN)
#ifdef Q_OS_DARWIN
QString QCoreApplicationPrivate::infoDictionaryStringProperty(const QString &propertyName)
{
    QString bundleName;
    QCFString cfPropertyName = propertyName.toCFString();
    CFTypeRef string = CFBundleGetValueForInfoDictionaryKey(CFBundleGetMainBundle(),
                                                            cfPropertyName);
    if (string)
        bundleName = QString::fromCFString(static_cast<CFStringRef>(string));
    return bundleName;
}
#endif
QString QCoreApplicationPrivate::appName() const
{
    QString applicationName;
#ifdef Q_OS_DARWIN
    applicationName = infoDictionaryStringProperty(QStringLiteral("CFBundleName"));
#endif
    if (applicationName.isEmpty() && argv[0]) {
        char *p = strrchr(argv[0], '/');
        applicationName = QString::fromLocal8Bit(p ? p + 1 : argv[0]);
    }
 
    return applicationName;
}
QString QCoreApplicationPrivate::appVersion() const
{
    QString applicationVersion;
#ifdef QT_BOOTSTRAPPED
#elif defined(Q_OS_DARWIN)
    applicationVersion = infoDictionaryStringProperty(QStringLiteral("CFBundleVersion"));
#elif defined(Q_OS_ANDROID)
    QJniObject context(QNativeInterface::QAndroidApplication::context());
    if (context.isValid()) {
        QJniObject pm = context.callObjectMethod(
            "getPackageManager", "()Landroid/content/pm/PackageManager;");
        QJniObject pn = context.callObjectMethod<jstring>("getPackageName");
        if (pm.isValid() && pn.isValid()) {
            QJniObject packageInfo = pm.callObjectMethod(
                "getPackageInfo", "(Ljava/lang/String;I)Landroid/content/pm/PackageInfo;",
                pn.object(), 0);
            if (packageInfo.isValid()) {
                QJniObject versionName = packageInfo.getObjectField(
                    "versionName", "Ljava/lang/String;");
                if (versionName.isValid())
                    return versionName.toString();
            }
        }
    }
#endif
    return applicationVersion;
}
#endif // !Q_OS_WIN
 
Q_CONSTINIT QString *QCoreApplicationPrivate::cachedApplicationFilePath = nullptr;
 
bool QCoreApplicationPrivate::checkInstance(const char *function)
{
    bool b = (QCoreApplication::self != nullptr);
    if (!b)
        qWarning("QApplication::%s: Please instantiate the QApplication object first", function);
    return b;
}
 
#if QT_CONFIG(commandlineparser)
void QCoreApplicationPrivate::addQtOptions(QList<QCommandLineOption> *options)
{
    options->append(QCommandLineOption(QStringLiteral("qmljsdebugger"),
                QStringLiteral("Activates the QML/JS debugger with a specified port. The value must be of format port:1234[,block]. \"block\" makes the application wait for a connection."),
                QStringLiteral("value")));
}
#endif
 
void QCoreApplicationPrivate::processCommandLineArguments()
{
    int j = argc ? 1 : 0;
    for (int i = 1; i < argc; ++i) {
        if (!argv[i])
            continue;
        if (*argv[i] != '-') {
            argv[j++] = argv[i];
            continue;
        }
        const char *arg = argv[i];
        if (arg[1] == '-') // startsWith("--")
            ++arg;
        if (strncmp(arg, "-qmljsdebugger=", 15) == 0) {
            qmljs_debug_arguments = QString::fromLocal8Bit(arg + 15);
        } else if (strcmp(arg, "-qmljsdebugger") == 0 && i < argc - 1) {
            ++i;
            qmljs_debug_arguments = QString::fromLocal8Bit(argv[i]);
        } else {
            argv[j++] = argv[i];
        }
    }
 
    if (j < argc) {
        argv[j] = nullptr;
        argc = j;
    }
}
 
// Support for introspection
 
extern "C" void Q_DECL_EXPORT_OVERRIDABLE qt_startup_hook()
{
}
 
typedef QList<QtStartUpFunction> QStartUpFuncList;
Q_GLOBAL_STATIC(QStartUpFuncList, preRList)
typedef QList<QtCleanUpFunction> QVFuncList;
Q_GLOBAL_STATIC(QVFuncList, postRList)
Q_CONSTINIT static QBasicMutex globalRoutinesMutex;
Q_CONSTINIT static bool preRoutinesCalled = false;
 
void qAddPreRoutine(QtStartUpFunction p)
{
    QStartUpFuncList *list = preRList();
    if (!list)
        return;
 
    if (preRoutinesCalled) {
        Q_ASSERT(QCoreApplication::instance());
        p();
    }
 
    // Due to C++11 parallel dynamic initialization, this can be called
    // from multiple threads.
    const auto locker = qt_scoped_lock(globalRoutinesMutex);
    list->prepend(p); // in case QCoreApplication is re-created, see qt_call_pre_routines
}
 
void qAddPostRoutine(QtCleanUpFunction p)
{
    QVFuncList *list = postRList();
    if (!list)
        return;
    const auto locker = qt_scoped_lock(globalRoutinesMutex);
    list->prepend(p);
}
 
void qRemovePostRoutine(QtCleanUpFunction p)
{
    QVFuncList *list = postRList();
    if (!list)
        return;
    const auto locker = qt_scoped_lock(globalRoutinesMutex);
    list->removeAll(p);
}
 
static void qt_call_pre_routines()
{
    // After will be allowed invoke QtStartUpFunction when calling qAddPreRoutine
    preRoutinesCalled = true;
 
    if (!preRList.exists())
        return;
 
    QVFuncList list;
    {
        const auto locker = qt_scoped_lock(globalRoutinesMutex);
        // Unlike qt_call_post_routines, we don't empty the list, because
        // Q_COREAPP_STARTUP_FUNCTION is a macro, so the user expects
        // the function to be executed every time QCoreApplication is created.
        list = *preRList;
    }
    for (QtCleanUpFunction f : std::as_const(list))
        f();
}
 
void Q_CORE_EXPORT qt_call_post_routines()
{
    if (!postRList.exists())
        return;
 
    forever {
        QVFuncList list;
        {
            // extract the current list and make the stored list empty
            const auto locker = qt_scoped_lock(globalRoutinesMutex);
            qSwap(*postRList, list);
        }
 
        if (list.isEmpty())
            break;
        for (QtCleanUpFunction f : std::as_const(list))
            f();
    }
}
 
 
#ifndef QT_NO_QOBJECT
 
// app starting up if false
Q_CONSTINIT bool QCoreApplicationPrivate::is_app_running = false;
 // app closing down if true
Q_CONSTINIT bool QCoreApplicationPrivate::is_app_closing = false;
 
qsizetype qGlobalPostedEventsCount()
{
    const QPostEventList &l = QThreadData::current()->postEventList;
    return l.size() - l.startOffset;
}
 
Q_CONSTINIT QAbstractEventDispatcher *QCoreApplicationPrivate::eventDispatcher = nullptr;
 
#endif // QT_NO_QOBJECT
 
Q_CONSTINIT QCoreApplication *QCoreApplication::self = nullptr;
Q_CONSTINIT uint QCoreApplicationPrivate::attribs =
    (1 << Qt::AA_SynthesizeMouseForUnhandledTouchEvents) |
    (1 << Qt::AA_SynthesizeMouseForUnhandledTabletEvents);
 
struct QCoreApplicationData {
    QCoreApplicationData() noexcept {
        applicationNameSet = false;
        applicationVersionSet = false;
    }
    ~QCoreApplicationData() {
#ifndef QT_NO_QOBJECT
        // cleanup the QAdoptedThread created for the main() thread
        if (auto *t = QCoreApplicationPrivate::theMainThread.loadAcquire()) {
            QThreadData *data = QThreadData::get2(t);
            data->deref(); // deletes the data and the adopted thread
        }
#endif
    }
 
    QString orgName, orgDomain;
    QString application; // application name, initially from argv[0], can then be modified.
    QString applicationVersion;
    bool applicationNameSet; // true if setApplicationName was called
    bool applicationVersionSet; // true if setApplicationVersion was called
 
#if QT_CONFIG(library)
    std::unique_ptr<QStringList> app_libpaths;
    std::unique_ptr<QStringList> manual_libpaths;
#endif
 
};
 
Q_GLOBAL_STATIC(QCoreApplicationData, coreappdata)
 
#ifndef QT_NO_QOBJECT
Q_CONSTINIT static bool quitLockEnabled = true;
#endif
 
#if defined(Q_OS_WIN)
// Check whether the command line arguments passed to QCoreApplication
// match those passed into main(), to see if the user has modified them
// before passing them on to us. We do this by comparing to the global
// __argv/__argc (MS extension). Deep comparison is required since
// argv/argc is rebuilt by our WinMain entrypoint.
static inline bool isArgvModified(int argc, char **argv)
{
    if (__argc != argc || !__argv /* wmain() */)
        return true;
    if (__argv == argv)
        return false;
    for (int a = 0; a < argc; ++a) {
        if (argv[a] != __argv[a] && strcmp(argv[a], __argv[a]))
            return true;
    }
    return false;
}
 
static inline bool contains(int argc, char **argv, const char *needle)
{
    for (int a = 0; a < argc; ++a) {
        if (!strcmp(argv[a], needle))
            return true;
    }
    return false;
}
#endif // Q_OS_WIN
 
QCoreApplicationPrivate::QCoreApplicationPrivate(int &aargc, char **aargv)
    :
#ifndef QT_NO_QOBJECT
      QObjectPrivate(),
#endif
      argc(aargc)
    , argv(aargv)
#if defined(Q_OS_WIN)
    , origArgc(0)
    , origArgv(nullptr)
#endif
    , application_type(QCoreApplicationPrivate::Tty)
#ifndef QT_NO_QOBJECT
    , in_exec(false)
    , aboutToQuitEmitted(false)
    , threadData_clean(false)
#else
    , q_ptr(nullptr)
#endif
{
    static const char *const empty = "";
    if (argc == 0 || argv == nullptr) {
        argc = 0;
        argv = const_cast<char **>(&empty);
    }
#if defined(Q_OS_WIN)
    if (!isArgvModified(argc, argv)) {
        origArgc = argc;
        origArgv = new char *[argc];
        std::copy(argv, argv + argc, QT_MAKE_CHECKED_ARRAY_ITERATOR(origArgv, argc));
    }
#endif // Q_OS_WIN
 
#ifndef QT_NO_QOBJECT
    QCoreApplicationPrivate::is_app_closing = false;
 
#  if defined(Q_OS_UNIX)
    if (Q_UNLIKELY(!setuidAllowed && (geteuid() != getuid())))
        qFatal("FATAL: The application binary appears to be running setuid, this is a security hole.");
#  endif // Q_OS_UNIX
 
    QThread *cur = QThread::currentThread(); // note: this may end up setting theMainThread!
    if (cur != theMainThread.loadAcquire())
        qWarning("WARNING: QApplication was not created in the main() thread.");
#endif
}
 
QCoreApplicationPrivate::~QCoreApplicationPrivate()
{
#ifndef QT_NO_QOBJECT
    cleanupThreadData();
#endif
#if defined(Q_OS_WIN)
    delete [] origArgv;
    if (consoleAllocated)
        FreeConsole();
#endif
    QCoreApplicationPrivate::clearApplicationFilePath();
}
 
#ifndef QT_NO_QOBJECT
 
void QCoreApplicationPrivate::cleanupThreadData()
{
    auto thisThreadData = threadData.loadRelaxed();
 
    if (thisThreadData && !threadData_clean) {
#if QT_CONFIG(thread)
        void *data = &thisThreadData->tls;
        QThreadStorageData::finish((void **)data);
#endif
 
        // need to clear the state of the mainData, just in case a new QCoreApplication comes along.
        const auto locker = qt_scoped_lock(thisThreadData->postEventList.mutex);
        for (const QPostEvent &pe : std::as_const(thisThreadData->postEventList)) {
            if (pe.event) {
                --pe.receiver->d_func()->postedEvents;
                pe.event->m_posted = false;
                delete pe.event;
            }
        }
        thisThreadData->postEventList.clear();
        thisThreadData->postEventList.recursion = 0;
        thisThreadData->quitNow = false;
        threadData_clean = true;
    }
}
 
void QCoreApplicationPrivate::createEventDispatcher()
{
    Q_Q(QCoreApplication);
    QThreadData *data = QThreadData::current();
    Q_ASSERT(!data->hasEventDispatcher());
    eventDispatcher = data->createEventDispatcher();
    eventDispatcher->setParent(q);
}
 
void QCoreApplicationPrivate::eventDispatcherReady()
{
}
 
Q_CONSTINIT QBasicAtomicPointer<QThread> QCoreApplicationPrivate::theMainThread = Q_BASIC_ATOMIC_INITIALIZER(nullptr);
QThread *QCoreApplicationPrivate::mainThread()
{
    Q_ASSERT(theMainThread.loadRelaxed() != nullptr);
    return theMainThread.loadRelaxed();
}
 
bool QCoreApplicationPrivate::threadRequiresCoreApplication()
{
    QThreadData *data = QThreadData::current(false);
    if (!data)
        return true;    // default setting
    return data->requiresCoreApplication;
}
 
void QCoreApplicationPrivate::checkReceiverThread(QObject *receiver)
{
    QThread *currentThread = QThread::currentThread();
    QThread *thr = receiver->thread();
    Q_ASSERT_X(currentThread == thr || !thr,
               "QCoreApplication::sendEvent",
               QString::asprintf("Cannot send events to objects owned by a different thread. "
                                 "Current thread 0x%p. Receiver '%ls' (of type '%s') was created in thread 0x%p",
                                 currentThread, qUtf16Printable(receiver->objectName()),
                                 receiver->metaObject()->className(), thr)
               .toLocal8Bit().data());
    Q_UNUSED(currentThread);
    Q_UNUSED(thr);
}
 
#endif // QT_NO_QOBJECT
 
void QCoreApplicationPrivate::appendApplicationPathToLibraryPaths()
{
#if QT_CONFIG(library)
    QStringList *app_libpaths = coreappdata()->app_libpaths.get();
    if (!app_libpaths)
        coreappdata()->app_libpaths.reset(app_libpaths = new QStringList);
    QString app_location = QCoreApplication::applicationFilePath();
    app_location.truncate(app_location.lastIndexOf(u'/'));
    app_location = QDir(app_location).canonicalPath();
    if (QFile::exists(app_location) && !app_libpaths->contains(app_location))
        app_libpaths->append(app_location);
#endif
}
 
QString qAppName()
{
    if (!QCoreApplicationPrivate::checkInstance("qAppName"))
        return QString();
    return QCoreApplication::instance()->d_func()->appName();
}
 
void QCoreApplicationPrivate::initConsole()
{
#ifdef Q_OS_WINDOWS
    const QString env = qEnvironmentVariable("QT_WIN_DEBUG_CONSOLE");
    if (env.isEmpty())
        return;
    if (env.compare(u"new"_s, Qt::CaseInsensitive) == 0) {
        if (AllocConsole() == FALSE)
            return;
        consoleAllocated = true;
    } else if (env.compare(u"attach"_s, Qt::CaseInsensitive) == 0) {
        if (AttachConsole(ATTACH_PARENT_PROCESS) == FALSE)
            return;
    } else {
        // Unknown input, don't make any decision for the user.
        return;
    }
    // The std{in,out,err} handles are read-only, so we need to pass in dummies.
    FILE *in = nullptr;
    FILE *out = nullptr;
    FILE *err = nullptr;
    freopen_s(&in, "CONIN$", "r", stdin);
    freopen_s(&out, "CONOUT$", "w", stdout);
    freopen_s(&err, "CONOUT$", "w", stderr);
    // However, things wouldn't work if the runtime did not preserve the pointers.
    Q_ASSERT(in == stdin);
    Q_ASSERT(out == stdout);
    Q_ASSERT(err == stderr);
#endif
}
 
void QCoreApplicationPrivate::initLocale()
{
#if defined(QT_BOOTSTRAPPED)
    // Don't try to control bootstrap library locale or encoding.
#elif defined(Q_OS_UNIX)
    Q_CONSTINIT static bool qt_locale_initialized = false;
    if (qt_locale_initialized)
        return;
    qt_locale_initialized = true;
 
    // By default the portable "C"/POSIX locale is selected and active.
    // Apply the locale from the environment, via setlocale(), which will
    // read LC_ALL, LC_<category>, and LANG, in order (for each category).
    setlocale(LC_ALL, "");
 
    // Next, let's ensure that LC_CTYPE is UTF-8, since QStringConverter's
    // QLocal8Bit hard-codes this, and we need to be consistent.
#  if defined(Q_OS_INTEGRITY)
    setlocale(LC_CTYPE, "UTF-8");
#  elif defined(Q_OS_QNX)
    // QNX has no nl_langinfo, so we can't check.
    // FIXME: Shouldn't we still setlocale("UTF-8")?
#  elif defined(Q_OS_ANDROID) && __ANDROID_API__ < __ANDROID_API_O__
    // Android 6 still lacks nl_langinfo(), so we can't check.
    // FIXME: Shouldn't we still setlocale("UTF-8")?
#  else
    // std::string's SSO usually saves this the need to allocate:
    const std::string oldEncoding = nl_langinfo(CODESET);
    if (!Q_LIKELY(qstricmp(oldEncoding.data(), "UTF-8") == 0
                  || qstricmp(oldEncoding.data(), "utf8") == 0)) {
        const QByteArray oldLocale = setlocale(LC_ALL, nullptr);
        QByteArray newLocale;
        bool warnOnOverride = true;
#    if defined(Q_OS_DARWIN)
        // Don't warn unless the char encoding has been changed from the
        // default "C" encoding, or the user touched any of the locale
        // environment variables to force the "C" char encoding.
        warnOnOverride = qstrcmp(setlocale(LC_CTYPE, nullptr), "C") != 0
            || getenv("LC_ALL") || getenv("LC_CTYPE") || getenv("LANG");
 
        // No need to try language or region specific CTYPEs, as they
        // all point back to the same generic UTF-8 CTYPE.
        newLocale = setlocale(LC_CTYPE, "UTF-8");
#    else
        newLocale = setlocale(LC_CTYPE, nullptr);
        if (qsizetype dot = newLocale.indexOf('.'); dot != -1)
            newLocale.truncate(dot);    // remove encoding, if any
        if (qsizetype at = newLocale.indexOf('@'); at != -1)
            newLocale.truncate(at);     // remove variant, as the old de_DE@euro
        newLocale += ".UTF-8";
        newLocale = setlocale(LC_CTYPE, newLocale);
 
        // If that locale doesn't exist, try some fallbacks:
        if (newLocale.isEmpty())
            newLocale = setlocale(LC_CTYPE, "C.UTF-8");
        if (newLocale.isEmpty())
            newLocale = setlocale(LC_CTYPE, "C.utf8");
#    endif
 
        if (newLocale.isEmpty()) {
            // Failed to set a UTF-8 locale.
            qWarning("Detected locale \"%s\" with character encoding \"%s\", which is not UTF-8.\n"
                     "Qt depends on a UTF-8 locale, but has failed to switch to one.\n"
                     "If this causes problems, reconfigure your locale. See the locale(1) manual\n"
                     "for more information.", oldLocale.constData(), oldEncoding.data());
        } else if (warnOnOverride) {
            // Let the user know we over-rode their configuration.
            qWarning("Detected locale \"%s\" with character encoding \"%s\", which is not UTF-8.\n"
                     "Qt depends on a UTF-8 locale, and has switched to \"%s\" instead.\n"
                     "If this causes problems, reconfigure your locale. See the locale(1) manual\n"
                     "for more information.",
                     oldLocale.constData(), oldEncoding.data(), newLocale.constData());
        }
    }
#  endif // Platform choice
#endif // Unix
}
 
 
QCoreApplication::QCoreApplication(QCoreApplicationPrivate &p)
#ifdef QT_NO_QOBJECT
    : d_ptr(&p)
#else
    : QObject(p, nullptr)
#endif
{
    d_func()->q_ptr = this;
    // note: it is the subclasses' job to call
    // QCoreApplicationPrivate::eventDispatcher->startingUp();
}
 
QCoreApplication::QCoreApplication(int &argc, char **argv
#ifndef Q_QDOC
                                   , int
#endif
                                   )
#ifdef QT_NO_QOBJECT
    : d_ptr(new QCoreApplicationPrivate(argc, argv))
#else
    : QObject(*new QCoreApplicationPrivate(argc, argv))
#endif
{
    d_func()->q_ptr = this;
    d_func()->init();
#ifndef QT_NO_QOBJECT
    QCoreApplicationPrivate::eventDispatcher->startingUp();
#endif
}
 
void Q_TRACE_INSTRUMENT(qtcore) QCoreApplicationPrivate::init()
{
    Q_TRACE_SCOPE(QCoreApplicationPrivate_init);
 
#if defined(Q_OS_MACOS)
    QMacAutoReleasePool pool;
#endif
 
    Q_Q(QCoreApplication);
 
    initConsole();
 
    initLocale();
 
    Q_ASSERT_X(!QCoreApplication::self, "QCoreApplication", "there should be only one application object");
    QCoreApplication::self = q;
 
#if QT_CONFIG(thread)
#ifdef Q_OS_WASM
    emscripten::val hardwareConcurrency = emscripten::val::global("navigator")["hardwareConcurrency"];
    if (hardwareConcurrency.isUndefined())
        QThreadPrivate::idealThreadCount = 2;
    else
        QThreadPrivate::idealThreadCount = hardwareConcurrency.as<int>();
#endif
#endif
 
    // Store app name/version (so they're still available after QCoreApplication is destroyed)
    if (!coreappdata()->applicationNameSet)
        coreappdata()->application = appName();
 
    if (!coreappdata()->applicationVersionSet)
        coreappdata()->applicationVersion = appVersion();
 
#if defined(Q_OS_ANDROID)
    // We've deferred initializing the logging registry due to not being
    // able to guarantee that logging happened on the same thread as the
    // Qt main thread, but now that the Qt main thread is set up, we can
    // enable categorized logging.
    QLoggingRegistry::instance()->initializeRules();
#endif
 
#if QT_CONFIG(library)
    // Reset the lib paths, so that they will be recomputed, taking the availability of argv[0]
    // into account. If necessary, recompute right away and replay the manual changes on top of the
    // new lib paths.
    QStringList *appPaths = coreappdata()->app_libpaths.release();
    QStringList *manualPaths = coreappdata()->manual_libpaths.release();
    if (appPaths) {
        if (manualPaths) {
            // Replay the delta. As paths can only be prepended to the front or removed from
            // anywhere in the list, we can just linearly scan the lists and find the items that
            // have been removed. Once the original list is exhausted we know all the remaining
            // items have been added.
            QStringList newPaths(q->libraryPaths());
            for (qsizetype i = manualPaths->size(), j = appPaths->size(); i > 0 || j > 0; qt_noop()) {
                if (--j < 0) {
                    newPaths.prepend((*manualPaths)[--i]);
                } else if (--i < 0) {
                    newPaths.removeAll((*appPaths)[j]);
                } else if ((*manualPaths)[i] != (*appPaths)[j]) {
                    newPaths.removeAll((*appPaths)[j]);
                    ++i; // try again with next item.
                }
            }
            delete manualPaths;
            coreappdata()->manual_libpaths.reset(new QStringList(newPaths));
        }
        delete appPaths;
    }
#endif
 
#ifndef QT_NO_QOBJECT
    // use the event dispatcher created by the app programmer (if any)
    Q_ASSERT(!eventDispatcher);
    auto thisThreadData = threadData.loadRelaxed();
    eventDispatcher = thisThreadData->eventDispatcher.loadRelaxed();
 
    // otherwise we create one
    if (!eventDispatcher)
        createEventDispatcher();
    Q_ASSERT(eventDispatcher);
 
    if (!eventDispatcher->parent()) {
        eventDispatcher->moveToThread(thisThreadData->thread.loadAcquire());
        eventDispatcher->setParent(q);
    }
 
    thisThreadData->eventDispatcher = eventDispatcher;
    eventDispatcherReady();
#endif
 
    processCommandLineArguments();
 
    qt_call_pre_routines();
    qt_startup_hook();
#ifndef QT_BOOTSTRAPPED
    QtPrivate::initBindingStatusThreadId();
    if (Q_UNLIKELY(qtHookData[QHooks::Startup]))
        reinterpret_cast<QHooks::StartupCallback>(qtHookData[QHooks::Startup])();
#endif
 
#ifndef QT_NO_QOBJECT
    is_app_running = true; // No longer starting up.
#endif
}
 
QCoreApplication::~QCoreApplication()
{
    preRoutinesCalled = false;
 
    qt_call_post_routines();
 
    self = nullptr;
#ifndef QT_NO_QOBJECT
    QCoreApplicationPrivate::is_app_closing = true;
    QCoreApplicationPrivate::is_app_running = false;
#endif
 
#if QT_CONFIG(thread)
    // Synchronize and stop the global thread pool threads.
    QThreadPool *globalThreadPool = nullptr;
    QThreadPool *guiThreadPool = nullptr;
    QT_TRY {
        globalThreadPool = QThreadPool::globalInstance();
        guiThreadPool = QThreadPoolPrivate::qtGuiInstance();
    } QT_CATCH (...) {
        // swallow the exception, since destructors shouldn't throw
    }
    if (globalThreadPool) {
        globalThreadPool->waitForDone();
        delete globalThreadPool;
    }
    if (guiThreadPool) {
        guiThreadPool->waitForDone();
        delete guiThreadPool;
    }
#endif
 
#ifndef QT_NO_QOBJECT
    d_func()->threadData.loadRelaxed()->eventDispatcher = nullptr;
    if (QCoreApplicationPrivate::eventDispatcher)
        QCoreApplicationPrivate::eventDispatcher->closingDown();
    QCoreApplicationPrivate::eventDispatcher = nullptr;
#endif
 
#if QT_CONFIG(library)
    coreappdata()->app_libpaths.reset();
    coreappdata()->manual_libpaths.reset();
#endif
}
 
void QCoreApplication::setSetuidAllowed(bool allow)
{
    QCoreApplicationPrivate::setuidAllowed = allow;
}
 
bool QCoreApplication::isSetuidAllowed()
{
    return QCoreApplicationPrivate::setuidAllowed;
}
 
 
void QCoreApplication::setAttribute(Qt::ApplicationAttribute attribute, bool on)
{
    if (on)
        QCoreApplicationPrivate::attribs |= 1 << attribute;
    else
        QCoreApplicationPrivate::attribs &= ~(1 << attribute);
#if defined(QT_NO_QOBJECT)
    if (Q_UNLIKELY(qApp)) {
#else
    if (Q_UNLIKELY(QCoreApplicationPrivate::is_app_running)) {
#endif
        switch (attribute) {
            case Qt::AA_PluginApplication:
            case Qt::AA_UseDesktopOpenGL:
            case Qt::AA_UseOpenGLES:
            case Qt::AA_UseSoftwareOpenGL:
            case Qt::AA_ShareOpenGLContexts:
#ifdef QT_BOOTSTRAPPED
                qWarning("Attribute %d must be set before QCoreApplication is created.",
                         attribute);
#else
                qWarning("Attribute Qt::%s must be set before QCoreApplication is created.",
                         QMetaEnum::fromType<Qt::ApplicationAttribute>().valueToKey(attribute));
#endif
                break;
            default:
                break;
        }
    }
}
 
bool QCoreApplication::testAttribute(Qt::ApplicationAttribute attribute)
{
    return QCoreApplicationPrivate::testAttribute(attribute);
}
 
#ifndef QT_NO_QOBJECT
 
bool QCoreApplication::isQuitLockEnabled()
{
    return quitLockEnabled;
}
 
static bool doNotify(QObject *, QEvent *);
 
void QCoreApplication::setQuitLockEnabled(bool enabled)
{
    quitLockEnabled = enabled;
}
 
bool QCoreApplication::notifyInternal2(QObject *receiver, QEvent *event)
{
    bool selfRequired = QCoreApplicationPrivate::threadRequiresCoreApplication();
    if (!self && selfRequired)
        return false;
 
    // Make it possible for Qt Script to hook into events even
    // though QApplication is subclassed...
    bool result = false;
    void *cbdata[] = { receiver, event, &result };
    if (QInternal::activateCallbacks(QInternal::EventNotifyCallback, cbdata)) {
        return result;
    }
 
    // Qt enforces the rule that events can only be sent to objects in
    // the current thread, so receiver->d_func()->threadData is
    // equivalent to QThreadData::current(), just without the function
    // call overhead.
    QObjectPrivate *d = receiver->d_func();
    QThreadData *threadData = d->threadData.loadAcquire();
    QScopedScopeLevelCounter scopeLevelCounter(threadData);
    if (!selfRequired)
        return doNotify(receiver, event);
    return self->notify(receiver, event);
}
 
bool QCoreApplication::forwardEvent(QObject *receiver, QEvent *event, QEvent *originatingEvent)
{
    if (event && originatingEvent)
        event->m_spont = originatingEvent->m_spont;
 
    return notifyInternal2(receiver, event);
}
 
bool QCoreApplication::notify(QObject *receiver, QEvent *event)
{
    Q_ASSERT(receiver);
    Q_ASSERT(event);
 
    // no events are delivered after ~QCoreApplication() has started
    if (QCoreApplicationPrivate::is_app_closing)
        return true;
    return doNotify(receiver, event);
}
 
static bool doNotify(QObject *receiver, QEvent *event)
{
    Q_ASSERT(event);
 
    // ### Qt 7: turn into an assert
    if (receiver == nullptr) {                        // serious error
        qWarning("QCoreApplication::notify: Unexpected null receiver");
        return true;
    }
 
#ifndef QT_NO_DEBUG
    QCoreApplicationPrivate::checkReceiverThread(receiver);
#endif
 
    return receiver->isWidgetType() ? false : QCoreApplicationPrivate::notify_helper(receiver, event);
}
 
bool QCoreApplicationPrivate::sendThroughApplicationEventFilters(QObject *receiver, QEvent *event)
{
    // We can't access the application event filters outside of the main thread (race conditions)
    Q_ASSERT(receiver->d_func()->threadData.loadAcquire()->thread.loadRelaxed() == mainThread());
 
    if (extraData) {
        // application event filters are only called for objects in the GUI thread
        for (qsizetype i = 0; i < extraData->eventFilters.size(); ++i) {
            QObject *obj = extraData->eventFilters.at(i);
            if (!obj)
                continue;
            if (obj->d_func()->threadData.loadRelaxed() != threadData.loadRelaxed()) {
                qWarning("QCoreApplication: Application event filter cannot be in a different thread.");
                continue;
            }
            if (obj->eventFilter(receiver, event))
                return true;
        }
    }
    return false;
}
 
bool QCoreApplicationPrivate::sendThroughObjectEventFilters(QObject *receiver, QEvent *event)
{
    if (receiver != QCoreApplication::instance() && receiver->d_func()->extraData) {
        for (qsizetype i = 0; i < receiver->d_func()->extraData->eventFilters.size(); ++i) {
            QObject *obj = receiver->d_func()->extraData->eventFilters.at(i);
            if (!obj)
                continue;
            if (obj->d_func()->threadData.loadRelaxed() != receiver->d_func()->threadData.loadRelaxed()) {
                qWarning("QCoreApplication: Object event filter cannot be in a different thread.");
                continue;
            }
            if (obj->eventFilter(receiver, event))
                return true;
        }
    }
    return false;
}
 
bool QCoreApplicationPrivate::notify_helper(QObject *receiver, QEvent * event)
{
    // Note: when adjusting the tracepoints in here
    // consider adjusting QApplicationPrivate::notify_helper too.
    Q_TRACE(QCoreApplication_notify_entry, receiver, event, event->type());
    bool consumed = false;
    bool filtered = false;
    Q_TRACE_EXIT(QCoreApplication_notify_exit, consumed, filtered);
 
    // send to all application event filters (only does anything in the main thread)
    if (QCoreApplication::self
            && receiver->d_func()->threadData.loadRelaxed()->thread.loadAcquire() == mainThread()
            && QCoreApplication::self->d_func()->sendThroughApplicationEventFilters(receiver, event)) {
        filtered = true;
        return filtered;
    }
    // send to all receiver event filters
    if (sendThroughObjectEventFilters(receiver, event)) {
        filtered = true;
        return filtered;
    }
 
    // deliver the event
    consumed = receiver->event(event);
    return consumed;
}
 
bool QCoreApplication::startingUp()
{
    return !QCoreApplicationPrivate::is_app_running;
}
 
bool QCoreApplication::closingDown()
{
    return QCoreApplicationPrivate::is_app_closing;
}
 
 
void QCoreApplication::processEvents(QEventLoop::ProcessEventsFlags flags)
{
    QThreadData *data = QThreadData::current();
    if (!data->hasEventDispatcher())
        return;
    data->eventDispatcher.loadRelaxed()->processEvents(flags);
}
 
void QCoreApplication::processEvents(QEventLoop::ProcessEventsFlags flags, int ms)
{
    QCoreApplication::processEvents(flags, QDeadlineTimer(ms));
}
 
void QCoreApplication::processEvents(QEventLoop::ProcessEventsFlags flags, QDeadlineTimer deadline)
{
    // ### TODO: consider splitting this method into a public and a private
    //           one, so that a user-invoked processEvents can be detected
    //           and handled properly.
    QThreadData *data = QThreadData::current();
    if (!data->hasEventDispatcher())
        return;
 
    while (data->eventDispatcher.loadRelaxed()->processEvents(flags & ~QEventLoop::WaitForMoreEvents)) {
        if (deadline.hasExpired())
            break;
    }
}
 
/*****************************************************************************
  Main event loop wrappers
 *****************************************************************************/
 
int QCoreApplication::exec()
{
    if (!QCoreApplicationPrivate::checkInstance("exec"))
        return -1;
 
    QThreadData *threadData = self->d_func()->threadData.loadAcquire();
    if (threadData != QThreadData::current()) {
        qWarning("%s::exec: Must be called from the main thread", self->metaObject()->className());
        return -1;
    }
    if (!threadData->eventLoops.isEmpty()) {
        qWarning("QCoreApplication::exec: The event loop is already running");
        return -1;
    }
 
    threadData->quitNow = false;
    QEventLoop eventLoop;
    self->d_func()->in_exec = true;
    self->d_func()->aboutToQuitEmitted = false;
    int returnCode = eventLoop.exec(QEventLoop::ApplicationExec);
    threadData->quitNow = false;
 
    if (self)
        self->d_func()->execCleanup();
 
    return returnCode;
}
 
 
// Cleanup after eventLoop is done executing in QCoreApplication::exec().
// This is for use cases in which QCoreApplication is instantiated by a
// library and not by an application executable, for example, Active X
// servers.
 
void QCoreApplicationPrivate::execCleanup()
{
    threadData.loadRelaxed()->quitNow = false;
    in_exec = false;
    QCoreApplication::sendPostedEvents(nullptr, QEvent::DeferredDelete);
}
 
 
void QCoreApplication::exit(int returnCode)
{
    if (!self)
        return;
    QCoreApplicationPrivate *d = self->d_func();
    if (!d->aboutToQuitEmitted) {
        emit self->aboutToQuit(QCoreApplication::QPrivateSignal());
        d->aboutToQuitEmitted = true;
    }
    QThreadData *data = d->threadData.loadRelaxed();
    data->quitNow = true;
    for (qsizetype i = 0; i < data->eventLoops.size(); ++i) {
        QEventLoop *eventLoop = data->eventLoops.at(i);
        eventLoop->exit(returnCode);
    }
}
 
/*****************************************************************************
  QCoreApplication management of posted events
 *****************************************************************************/
 
#ifndef QT_NO_QOBJECT
bool QCoreApplication::sendEvent(QObject *receiver, QEvent *event)
{
    Q_ASSERT_X(receiver, "QCoreApplication::sendEvent", "Unexpected null receiver");
    Q_ASSERT_X(event, "QCoreApplication::sendEvent", "Unexpected null event");
 
    Q_TRACE(QCoreApplication_sendEvent, receiver, event, event->type());
 
    event->m_spont = false;
    return notifyInternal2(receiver, event);
}
 
bool QCoreApplication::sendSpontaneousEvent(QObject *receiver, QEvent *event)
{
    Q_ASSERT_X(receiver, "QCoreApplication::sendSpontaneousEvent", "Unexpected null receiver");
    Q_ASSERT_X(event, "QCoreApplication::sendSpontaneousEvent", "Unexpected null event");
 
    Q_TRACE(QCoreApplication_sendSpontaneousEvent, receiver, event, event->type());
 
    event->m_spont = true;
    return notifyInternal2(receiver, event);
}
 
#endif // QT_NO_QOBJECT
 
QCoreApplicationPrivate::QPostEventListLocker QCoreApplicationPrivate::lockThreadPostEventList(QObject *object)
{
    QPostEventListLocker locker;
 
    if (!object) {
        locker.threadData = QThreadData::current();
        locker.locker = qt_unique_lock(locker.threadData->postEventList.mutex);
        return locker;
    }
 
    auto &threadData = QObjectPrivate::get(object)->threadData;
 
    // if object has moved to another thread, follow it
    for (;;) {
        // synchronizes with the storeRelease in QObject::moveToThread
        locker.threadData = threadData.loadAcquire();
        if (!locker.threadData) {
            // destruction in progress
            return locker;
        }
 
        auto temporaryLocker = qt_unique_lock(locker.threadData->postEventList.mutex);
        if (locker.threadData == threadData.loadAcquire()) {
            locker.locker = std::move(temporaryLocker);
            break;
        }
    }
 
    Q_ASSERT(locker.threadData);
    return locker;
}
 
void QCoreApplication::postEvent(QObject *receiver, QEvent *event, int priority)
{
    Q_ASSERT_X(event, "QCoreApplication::postEvent", "Unexpected null event");
 
    Q_TRACE_SCOPE(QCoreApplication_postEvent, receiver, event, event->type());
 
    // ### Qt 7: turn into an assert
    if (receiver == nullptr) {
        qWarning("QCoreApplication::postEvent: Unexpected null receiver");
        delete event;
        return;
    }
 
    auto locker = QCoreApplicationPrivate::lockThreadPostEventList(receiver);
    if (!locker.threadData) {
        // posting during destruction? just delete the event to prevent a leak
        delete event;
        return;
    }
 
    QThreadData *data = locker.threadData;
 
    // if this is one of the compressible events, do compression
    if (receiver->d_func()->postedEvents
        && self && self->compressEvent(event, receiver, &data->postEventList)) {
        Q_TRACE(QCoreApplication_postEvent_event_compressed, receiver, event);
        return;
    }
 
    if (event->type() == QEvent::DeferredDelete)
        receiver->d_ptr->deleteLaterCalled = true;
 
    if (event->type() == QEvent::DeferredDelete && data == QThreadData::current()) {
        // remember the current running eventloop for DeferredDelete
        // events posted in the receiver's thread.
 
        // Events sent by non-Qt event handlers (such as glib) may not
        // have the scopeLevel set correctly. The scope level makes sure that
        // code like this:
        //     foo->deleteLater();
        //     qApp->processEvents(); // without passing QEvent::DeferredDelete
        // will not cause "foo" to be deleted before returning to the event loop.
 
        // If the scope level is 0 while loopLevel != 0, we are called from a
        // non-conformant code path, and our best guess is that the scope level
        // should be 1. (Loop level 0 is special: it means that no event loops
        // are running.)
        int loopLevel = data->loopLevel;
        int scopeLevel = data->scopeLevel;
        if (scopeLevel == 0 && loopLevel != 0)
            scopeLevel = 1;
 
        QDeferredDeleteEvent *deleteEvent = static_cast<QDeferredDeleteEvent *>(event);
        deleteEvent->m_loopLevel = loopLevel;
        deleteEvent->m_scopeLevel = scopeLevel;
    }
 
    // delete the event on exceptions to protect against memory leaks till the event is
    // properly owned in the postEventList
    std::unique_ptr<QEvent> eventDeleter(event);
    Q_TRACE(QCoreApplication_postEvent_event_posted, receiver, event, event->type());
    data->postEventList.addEvent(QPostEvent(receiver, event, priority));
    Q_UNUSED(eventDeleter.release());
    event->m_posted = true;
    ++receiver->d_func()->postedEvents;
    data->canWait = false;
    locker.unlock();
 
    QAbstractEventDispatcher* dispatcher = data->eventDispatcher.loadAcquire();
    if (dispatcher)
        dispatcher->wakeUp();
}
 
bool QCoreApplication::compressEvent(QEvent *event, QObject *receiver, QPostEventList *postedEvents)
{
    Q_ASSERT(event);
    Q_ASSERT(receiver);
    Q_ASSERT(postedEvents);
 
#ifdef Q_OS_WIN
    // compress posted timers to this object.
    if (event->type() == QEvent::Timer && receiver->d_func()->postedEvents > 0) {
        int timerId = ((QTimerEvent *) event)->timerId();
        for (const QPostEvent &e : std::as_const(*postedEvents)) {
            if (e.receiver == receiver && e.event && e.event->type() == QEvent::Timer
                && ((QTimerEvent *) e.event)->timerId() == timerId) {
                delete event;
                return true;
            }
        }
        return false;
    }
#endif
 
    if (event->type() == QEvent::DeferredDelete) {
        if (receiver->d_ptr->deleteLaterCalled) {
            // there was a previous DeferredDelete event, so we can drop the new one
            delete event;
            return true;
        }
        // deleteLaterCalled is set to true in postedEvents when queueing the very first
        // deferred deletion event.
        return false;
    }
 
    if (event->type() == QEvent::Quit && receiver->d_func()->postedEvents > 0) {
        for (const QPostEvent &cur : std::as_const(*postedEvents)) {
            if (cur.receiver != receiver
                    || cur.event == nullptr
                    || cur.event->type() != event->type())
                continue;
            // found an event for this receiver
            delete event;
            return true;
        }
    }
 
    return false;
}
 
void QCoreApplication::sendPostedEvents(QObject *receiver, int event_type)
{
    // ### TODO: consider splitting this method into a public and a private
    //           one, so that a user-invoked sendPostedEvents can be detected
    //           and handled properly.
    QThreadData *data = QThreadData::current();
 
    QCoreApplicationPrivate::sendPostedEvents(receiver, event_type, data);
}
 
void QCoreApplicationPrivate::sendPostedEvents(QObject *receiver, int event_type,
                                               QThreadData *data)
{
    if (event_type == -1) {
        // we were called by an obsolete event dispatcher.
        event_type = 0;
    }
 
    if (receiver && receiver->d_func()->threadData.loadRelaxed() != data) {
        qWarning("QCoreApplication::sendPostedEvents: Cannot send "
                 "posted events for objects in another thread");
        return;
    }
 
    ++data->postEventList.recursion;
 
    auto locker = qt_unique_lock(data->postEventList.mutex);
 
    // by default, we assume that the event dispatcher can go to sleep after
    // processing all events. if any new events are posted while we send
    // events, canWait will be set to false.
    data->canWait = (data->postEventList.size() == 0);
 
    if (data->postEventList.size() == 0 || (receiver && !receiver->d_func()->postedEvents)) {
        --data->postEventList.recursion;
        return;
    }
 
    data->canWait = true;
 
    // okay. here is the tricky loop. be careful about optimizing
    // this, it looks the way it does for good reasons.
    qsizetype startOffset = data->postEventList.startOffset;
    qsizetype &i = (!event_type && !receiver) ? data->postEventList.startOffset : startOffset;
    data->postEventList.insertionOffset = data->postEventList.size();
 
    // Exception-safe cleaning up without the need for a try/catch block
    struct CleanUp {
        QObject *receiver;
        int event_type;
        QThreadData *data;
        bool exceptionCaught;
 
        inline CleanUp(QObject *receiver, int event_type, QThreadData *data) :
            receiver(receiver), event_type(event_type), data(data), exceptionCaught(true)
        {}
        inline ~CleanUp()
        {
            if (exceptionCaught) {
                // since we were interrupted, we need another pass to make sure we clean everything up
                data->canWait = false;
            }
 
            --data->postEventList.recursion;
            if (!data->postEventList.recursion && !data->canWait && data->hasEventDispatcher())
                data->eventDispatcher.loadRelaxed()->wakeUp();
 
            // clear the global list, i.e. remove everything that was
            // delivered.
            if (!event_type && !receiver && data->postEventList.startOffset >= 0) {
                const QPostEventList::iterator it = data->postEventList.begin();
                data->postEventList.erase(it, it + data->postEventList.startOffset);
                data->postEventList.insertionOffset -= data->postEventList.startOffset;
                Q_ASSERT(data->postEventList.insertionOffset >= 0);
                data->postEventList.startOffset = 0;
            }
        }
    };
    CleanUp cleanup(receiver, event_type, data);
 
    while (i < data->postEventList.size()) {
        // avoid live-lock
        if (i >= data->postEventList.insertionOffset)
            break;
 
        const QPostEvent &pe = data->postEventList.at(i);
        ++i;
 
        if (!pe.event)
            continue;
        if ((receiver && receiver != pe.receiver) || (event_type && event_type != pe.event->type())) {
            data->canWait = false;
            continue;
        }
 
        if (pe.event->type() == QEvent::DeferredDelete) {
            // DeferredDelete events are sent either
            // 1) when the event loop that posted the event has returned; or
            // 2) if explicitly requested (with QEvent::DeferredDelete) for
            //    events posted by the current event loop; or
            // 3) if the event was posted before the outermost event loop.
 
            const int eventLoopLevel = static_cast<QDeferredDeleteEvent *>(pe.event)->loopLevel();
            const int eventScopeLevel = static_cast<QDeferredDeleteEvent *>(pe.event)->scopeLevel();
 
            const bool postedBeforeOutermostLoop = eventLoopLevel == 0;
            const bool allowDeferredDelete =
                (eventLoopLevel + eventScopeLevel > data->loopLevel + data->scopeLevel
                 || (postedBeforeOutermostLoop && data->loopLevel > 0)
                 || (event_type == QEvent::DeferredDelete
                     && eventLoopLevel + eventScopeLevel == data->loopLevel + data->scopeLevel));
            if (!allowDeferredDelete) {
                // cannot send deferred delete
                if (!event_type && !receiver) {
                    // we must copy it first; we want to re-post the event
                    // with the event pointer intact, but we can't delay
                    // nulling the event ptr until after re-posting, as
                    // addEvent may invalidate pe.
                    QPostEvent pe_copy = pe;
 
                    // null out the event so if sendPostedEvents recurses, it
                    // will ignore this one, as it's been re-posted.
                    const_cast<QPostEvent &>(pe).event = nullptr;
 
                    // re-post the copied event so it isn't lost
                    data->postEventList.addEvent(pe_copy);
                }
                continue;
            }
        }
 
        // first, we diddle the event so that we can deliver
        // it, and that no one will try to touch it later.
        pe.event->m_posted = false;
        QEvent *e = pe.event;
        QObject * r = pe.receiver;
 
        --r->d_func()->postedEvents;
        Q_ASSERT(r->d_func()->postedEvents >= 0);
 
        // next, update the data structure so that we're ready
        // for the next event.
        const_cast<QPostEvent &>(pe).event = nullptr;
 
        locker.unlock();
        const auto relocker = qScopeGuard([&locker] { locker.lock(); });
 
        QScopedPointer<QEvent> event_deleter(e); // will delete the event (with the mutex unlocked)
 
        // after all that work, it's time to deliver the event.
        QCoreApplication::sendEvent(r, e);
 
        // careful when adding anything below this point - the
        // sendEvent() call might invalidate any invariants this
        // function depends on.
    }
 
    cleanup.exceptionCaught = false;
}
 
void QCoreApplication::removePostedEvents(QObject *receiver, int eventType)
{
    auto locker = QCoreApplicationPrivate::lockThreadPostEventList(receiver);
    QThreadData *data = locker.threadData;
 
    // the QObject destructor calls this function directly.  this can
    // happen while the event loop is in the middle of posting events,
    // and when we get here, we may not have any more posted events
    // for this object.
    if (receiver && !receiver->d_func()->postedEvents)
        return;
 
    //we will collect all the posted events for the QObject
    //and we'll delete after the mutex was unlocked
    QVarLengthArray<QEvent*> events;
    qsizetype n = data->postEventList.size();
    qsizetype j = 0;
 
    for (qsizetype i = 0; i < n; ++i) {
        const QPostEvent &pe = data->postEventList.at(i);
 
        if ((!receiver || pe.receiver == receiver)
            && (pe.event && (eventType == 0 || pe.event->type() == eventType))) {
            --pe.receiver->d_func()->postedEvents;
            pe.event->m_posted = false;
            events.append(pe.event);
            const_cast<QPostEvent &>(pe).event = nullptr;
        } else if (!data->postEventList.recursion) {
            if (i != j)
                qSwap(data->postEventList[i], data->postEventList[j]);
            ++j;
        }
    }
 
#ifdef QT_DEBUG
    if (receiver && eventType == 0) {
        Q_ASSERT(!receiver->d_func()->postedEvents);
    }
#endif
 
    if (!data->postEventList.recursion) {
        // truncate list
        data->postEventList.erase(data->postEventList.begin() + j, data->postEventList.end());
    }
 
    locker.unlock();
    qDeleteAll(events);
}
 
void QCoreApplicationPrivate::removePostedEvent(QEvent * event)
{
    if (!event || !event->m_posted)
        return;
 
    QThreadData *data = QThreadData::current();
 
    const auto locker = qt_scoped_lock(data->postEventList.mutex);
 
    if (data->postEventList.size() == 0) {
#if defined(QT_DEBUG)
        qDebug("QCoreApplication::removePostedEvent: Internal error: %p %d is posted",
                (void*)event, event->type());
        return;
#endif
    }
 
    for (const QPostEvent &pe : std::as_const(data->postEventList)) {
        if (pe.event == event) {
#ifndef QT_NO_DEBUG
            qWarning("QCoreApplication::removePostedEvent: Event of type %d deleted while posted to %s %s",
                     event->type(),
                     pe.receiver->metaObject()->className(),
                     pe.receiver->objectName().toLocal8Bit().data());
#endif
            --pe.receiver->d_func()->postedEvents;
            pe.event->m_posted = false;
            delete pe.event;
            const_cast<QPostEvent &>(pe).event = nullptr;
            return;
        }
    }
}
 
bool QCoreApplication::event(QEvent *e)
{
    if (e->type() == QEvent::Quit) {
        exit(0);
        return true;
    }
    return QObject::event(e);
}
 
void QCoreApplicationPrivate::ref()
{
    quitLockRef.ref();
}
 
void QCoreApplicationPrivate::deref()
{
    quitLockRef.deref();
 
    if (quitLockEnabled && canQuitAutomatically())
        quitAutomatically();
}
 
bool QCoreApplicationPrivate::canQuitAutomatically()
{
    if (!in_exec)
        return false;
 
    if (quitLockEnabled && quitLockRef.loadRelaxed())
        return false;
 
    return true;
}
 
void QCoreApplicationPrivate::quitAutomatically()
{
    Q_Q(QCoreApplication);
 
    // Explicit requests by the user to quit() is plumbed via the platform
    // if possible, and delivers the quit event synchronously. For automatic
    // quits we implicitly support cancelling the quit by showing another
    // window, which currently relies on removing any posted quit events
    // from the event queue. As a result, we can't use the normal quit()
    // code path, and need to post manually.
    QCoreApplication::postEvent(q, new QEvent(QEvent::Quit));
}
 
void QCoreApplication::quit()
{
    if (!self)
        return;
 
    if (!self->d_func()->in_exec)
        return;
 
    self->d_func()->quit();
}
 
void QCoreApplicationPrivate::quit()
{
    Q_Q(QCoreApplication);
 
    if (QThread::currentThread() == mainThread()) {
        QEvent quitEvent(QEvent::Quit);
        QCoreApplication::sendEvent(q, &quitEvent);
    } else {
        QCoreApplication::postEvent(q, new QEvent(QEvent::Quit));
    }
}
 
#endif // QT_NO_QOBJECT
 
#ifndef QT_NO_TRANSLATION
bool QCoreApplication::installTranslator(QTranslator *translationFile)
{
    if (!translationFile)
        return false;
 
    if (!QCoreApplicationPrivate::checkInstance("installTranslator"))
        return false;
    QCoreApplicationPrivate *d = self->d_func();
    {
        QWriteLocker locker(&d->translateMutex);
        d->translators.prepend(translationFile);
    }
 
#ifndef QT_NO_TRANSLATION_BUILDER
    if (translationFile->isEmpty())
        return false;
#endif
 
#ifndef QT_NO_QOBJECT
    QEvent ev(QEvent::LanguageChange);
    QCoreApplication::sendEvent(self, &ev);
#endif
 
    return true;
}
 
bool QCoreApplication::removeTranslator(QTranslator *translationFile)
{
    if (!translationFile)
        return false;
    if (!QCoreApplicationPrivate::checkInstance("removeTranslator"))
        return false;
    QCoreApplicationPrivate *d = self->d_func();
    QWriteLocker locker(&d->translateMutex);
    if (d->translators.removeAll(translationFile)) {
#ifndef QT_NO_QOBJECT
        locker.unlock();
        if (!self->closingDown()) {
            QEvent ev(QEvent::LanguageChange);
            QCoreApplication::sendEvent(self, &ev);
        }
#endif
        return true;
    }
    return false;
}
 
static void replacePercentN(QString *result, int n)
{
    if (n >= 0) {
        qsizetype percentPos = 0;
        qsizetype len = 0;
        while ((percentPos = result->indexOf(u'%', percentPos + len)) != -1) {
            len = 1;
            if (percentPos + len == result->size())
                break;
            QString fmt;
            if (result->at(percentPos + len) == u'L') {
                ++len;
                if (percentPos + len == result->size())
                    break;
                fmt = "%L1"_L1;
            } else {
                fmt = "%1"_L1;
            }
            if (result->at(percentPos + len) == u'n') {
                fmt = fmt.arg(n);
                ++len;
                result->replace(percentPos, len, fmt);
                len = fmt.size();
            }
        }
    }
}
 
QString QCoreApplication::translate(const char *context, const char *sourceText,
                                    const char *disambiguation, int n)
{
    QString result;
 
    if (!sourceText)
        return result;
 
    if (self) {
        QCoreApplicationPrivate *d = self->d_func();
        QReadLocker locker(&d->translateMutex);
        if (!d->translators.isEmpty()) {
            QList<QTranslator*>::ConstIterator it;
            QTranslator *translationFile;
            for (it = d->translators.constBegin(); it != d->translators.constEnd(); ++it) {
                translationFile = *it;
                result = translationFile->translate(context, sourceText, disambiguation, n);
                if (!result.isNull())
                    break;
            }
        }
    }
 
    if (result.isNull())
        result = QString::fromUtf8(sourceText);
 
    replacePercentN(&result, n);
    return result;
}
 
// Declared in qglobal.h
QString qtTrId(const char *id, int n)
{
    return QCoreApplication::translate(nullptr, id, nullptr, n);
}
 
bool QCoreApplicationPrivate::isTranslatorInstalled(QTranslator *translator)
{
    if (!QCoreApplication::self)
        return false;
    QCoreApplicationPrivate *d = QCoreApplication::self->d_func();
    QReadLocker locker(&d->translateMutex);
    return d->translators.contains(translator);
}
 
#else
 
QString QCoreApplication::translate(const char *context, const char *sourceText,
                                    const char *disambiguation, int n)
{
    Q_UNUSED(context);
    Q_UNUSED(disambiguation);
    QString ret = QString::fromUtf8(sourceText);
    if (n >= 0)
        ret.replace("%n"_L1, QString::number(n));
    return ret;
}
 
#endif //QT_NO_TRANSLATION
 
// Makes it possible to point QCoreApplication to a custom location to ensure
// the directory is added to the patch, and qt.conf and deployed plugins are
// found from there. This is for use cases in which QGuiApplication is
// instantiated by a library and not by an application executable, for example,
// Active X servers.
 
void QCoreApplicationPrivate::setApplicationFilePath(const QString &path)
{
    if (QCoreApplicationPrivate::cachedApplicationFilePath)
        *QCoreApplicationPrivate::cachedApplicationFilePath = path;
    else
        QCoreApplicationPrivate::cachedApplicationFilePath = new QString(path);
}
 
QString QCoreApplication::applicationDirPath()
{
    if (!self) {
        qWarning("QCoreApplication::applicationDirPath: Please instantiate the QApplication object first");
        return QString();
    }
 
    QCoreApplicationPrivate *d = self->d_func();
    if (d->cachedApplicationDirPath.isNull())
        d->cachedApplicationDirPath = QFileInfo(applicationFilePath()).path();
    return d->cachedApplicationDirPath;
}
 
#if !defined(Q_OS_WIN) && !defined(Q_OS_DARWIN)     // qcoreapplication_win.cpp or qcoreapplication_mac.cpp
static QString qAppFileName()
{
#  if defined(Q_OS_ANDROID)
    // the actual process on Android is the Java VM, so this doesn't help us
    return QString();
#  elif defined(Q_OS_LINUX)
    // this includes the Embedded Android builds
    return QFile::decodeName(qt_readlink("/proc/self/exe"));
#  elif defined(AT_EXECPATH)
    // seen on FreeBSD, but I suppose the other BSDs could adopt this API
    char execfn[PATH_MAX];
    if (elf_aux_info(AT_EXECPATH, execfn, sizeof(execfn)) != 0)
        execfn[0] = '\0';
 
    qsizetype len = qstrlen(execfn);
    return QFile::decodeName(QByteArray::fromRawData(execfn, len));
#  else
    // other OS or something
    return QString();
#endif
}
#endif
 
QString QCoreApplication::applicationFilePath()
{
    if (!self) {
        qWarning("QCoreApplication::applicationFilePath: Please instantiate the QApplication object first");
        return QString();
    }
 
    QCoreApplicationPrivate *d = self->d_func();
 
    if (d->argc) {
        static QByteArray procName = QByteArray(d->argv[0]);
        if (procName != d->argv[0]) {
            // clear the cache if the procname changes, so we reprocess it.
            QCoreApplicationPrivate::clearApplicationFilePath();
            procName = QByteArray(d->argv[0]);
        }
    }
 
    if (QCoreApplicationPrivate::cachedApplicationFilePath)
        return *QCoreApplicationPrivate::cachedApplicationFilePath;
 
    QString absPath = qAppFileName();
    if (absPath.isEmpty() && !arguments().isEmpty()) {
        QString argv0 = QFile::decodeName(arguments().at(0).toLocal8Bit());
 
        if (!argv0.isEmpty() && argv0.at(0) == u'/') {
            /*
              If argv0 starts with a slash, it is already an absolute
              file path.
            */
            absPath = argv0;
        } else if (argv0.contains(u'/')) {
            /*
              If argv0 contains one or more slashes, it is a file path
              relative to the current directory.
            */
            absPath = QDir::current().absoluteFilePath(argv0);
        } else {
            /*
              Otherwise, the file path has to be determined using the
              PATH environment variable.
            */
            absPath = QStandardPaths::findExecutable(argv0);
        }
    }
 
    absPath = QFileInfo(absPath).canonicalFilePath();
    if (!absPath.isEmpty()) {
        QCoreApplicationPrivate::setApplicationFilePath(absPath);
        return *QCoreApplicationPrivate::cachedApplicationFilePath;
    }
    return QString();
}
 
qint64 QCoreApplication::applicationPid()
{
#if defined(Q_OS_WIN)
    return GetCurrentProcessId();
#elif defined(Q_OS_VXWORKS)
    return (pid_t) taskIdCurrent;
#else
    return getpid();
#endif
}
 
QStringList QCoreApplication::arguments()
{
    QStringList list;
 
    if (!self) {
        qWarning("QCoreApplication::arguments: Please instantiate the QApplication object first");
        return list;
    }
 
    const QCoreApplicationPrivate *d = self->d_func();
 
    const int argc = d->argc;
    char ** const argv = d->argv;
    list.reserve(argc);
 
#if defined(Q_OS_WIN)
    const bool argsModifiedByUser = d->origArgv == nullptr;
    if (!argsModifiedByUser) {
        // On Windows, it is possible to pass Unicode arguments on
        // the command line, but we don't implement any of the wide
        // entry-points (wmain/wWinMain), so get the arguments from
        // the Windows API instead of using argv. Note that we only
        // do this when argv were not modified by the user in main().
        QString cmdline = QString::fromWCharArray(GetCommandLine());
        QStringList commandLineArguments = qWinCmdArgs(cmdline);
 
        // Even if the user didn't modify argv before passing them
        // on to QCoreApplication, derived QApplications might have.
        // If that's the case argc will differ from origArgc.
        if (argc != d->origArgc) {
            // Note: On MingGW the arguments from GetCommandLine are
            // not wildcard expanded (if wildcard expansion is enabled),
            // as opposed to the arguments in argv. This means we can't
            // compare commandLineArguments to argv/origArgc, but
            // must remove elements by value, based on whether they
            // were filtered out from argc.
            for (int i = 0; i < d->origArgc; ++i) {
                if (!contains(argc, argv, d->origArgv[i]))
                    commandLineArguments.removeAll(QString::fromLocal8Bit(d->origArgv[i]));
            }
        }
 
        return commandLineArguments;
    } // Fall back to rebuilding from argv/argc when a modified argv was passed.
#endif // defined(Q_OS_WIN)
 
    for (int a = 0; a < argc; ++a)
        list << QString::fromLocal8Bit(argv[a]);
 
    return list;
}
 
void QCoreApplication::setOrganizationName(const QString &orgName)
{
    if (coreappdata()->orgName == orgName)
        return;
    coreappdata()->orgName = orgName;
#ifndef QT_NO_QOBJECT
    if (QCoreApplication::self)
        emit QCoreApplication::self->organizationNameChanged();
#endif
}
 
QString QCoreApplication::organizationName()
{
    return coreappdata()->orgName;
}
 
void QCoreApplication::setOrganizationDomain(const QString &orgDomain)
{
    if (coreappdata()->orgDomain == orgDomain)
        return;
    coreappdata()->orgDomain = orgDomain;
#ifndef QT_NO_QOBJECT
    if (QCoreApplication::self)
        emit QCoreApplication::self->organizationDomainChanged();
#endif
}
 
QString QCoreApplication::organizationDomain()
{
    return coreappdata()->orgDomain;
}
 
void QCoreApplication::setApplicationName(const QString &application)
{
    coreappdata()->applicationNameSet = !application.isEmpty();
    QString newAppName = application;
    if (newAppName.isEmpty() && QCoreApplication::self)
        newAppName = QCoreApplication::self->d_func()->appName();
    if (coreappdata()->application == newAppName)
        return;
    coreappdata()->application = newAppName;
#ifndef QT_NO_QOBJECT
    if (QCoreApplication::self)
        emit QCoreApplication::self->applicationNameChanged();
#endif
}
 
QString QCoreApplication::applicationName()
{
    return coreappdata() ? coreappdata()->application : QString();
}
 
void QCoreApplication::setApplicationVersion(const QString &version)
{
    coreappdata()->applicationVersionSet = !version.isEmpty();
    QString newVersion = version;
    if (newVersion.isEmpty() && QCoreApplication::self)
        newVersion = QCoreApplication::self->d_func()->appVersion();
    if (coreappdata()->applicationVersion == newVersion)
        return;
    coreappdata()->applicationVersion = newVersion;
#ifndef QT_NO_QOBJECT
    if (QCoreApplication::self)
        emit QCoreApplication::self->applicationVersionChanged();
#endif
}
 
QString QCoreApplication::applicationVersion()
{
    return coreappdata() ? coreappdata()->applicationVersion : QString();
}
 
#if QT_CONFIG(permissions) || defined(Q_QDOC)
 
Qt::PermissionStatus QCoreApplication::checkPermission(const QPermission &permission)
{
    return QPermissions::Private::checkPermission(permission);
}
 
void QCoreApplication::requestPermission(const QPermission &requestedPermission,
    QtPrivate::QSlotObjectBase *slotObj, const QObject *context)
{
    if (QThread::currentThread() != QCoreApplicationPrivate::mainThread()) {
        qWarning(lcPermissions, "Permissions can only be requested from the GUI (main) thread");
        return;
    }
 
    Q_ASSERT(slotObj);
 
    // Used as the signalID in the metacall event and only used to
    // verify that we are not processing an unrelated event, not to
    // emit the right signal. So using a value that can never clash
    // with any signal index. Clang doesn't like this to be a static
    // member of the PermissionReceiver.
    static constexpr ushort PermissionReceivedID = 0xffff;
 
    // If we have a context object, then we dispatch the permission response
    // asynchronously through a received object that lives in the same thread
    // as the context object. Otherwise we call the functor synchronously when
    // we get a response (which might still be asynchronous for the caller).
    class PermissionReceiver : public QObject
    {
    public:
        PermissionReceiver(QtPrivate::QSlotObjectBase *slotObject, const QObject *context)
            : slotObject(slotObject), context(context)
        {}
 
    protected:
        bool event(QEvent *event) override {
            if (event->type() == QEvent::MetaCall) {
                auto metaCallEvent = static_cast<QMetaCallEvent *>(event);
                if (metaCallEvent->id() == PermissionReceivedID) {
                    Q_ASSERT(slotObject);
                    // only execute if context object is still alive
                    if (context)
                        slotObject->call(const_cast<QObject*>(context.data()), metaCallEvent->args());
                    slotObject->destroyIfLastRef();
                    deleteLater();
 
                    return true;
                }
            }
            return QObject::event(event);
        }
    private:
        QtPrivate::QSlotObjectBase *slotObject;
        QPointer<const QObject> context;
    };
    PermissionReceiver *receiver = nullptr;
    if (context) {
        receiver = new PermissionReceiver(slotObj, context);
        receiver->moveToThread(context->thread());
    }
 
    QPermissions::Private::requestPermission(requestedPermission, [=](Qt::PermissionStatus status) {
        Q_ASSERT_X(status != Qt::PermissionStatus::Undetermined, "QPermission",
            "QCoreApplication::requestPermission() should never return Undetermined");
        if (status == Qt::PermissionStatus::Undetermined)
            status = Qt::PermissionStatus::Denied;
 
        if (QCoreApplication::self) {
            QPermission permission = requestedPermission;
            permission.m_status = status;
 
            if (receiver) {
                auto metaCallEvent = QMetaCallEvent::create(slotObj, qApp,
                                                            PermissionReceivedID, permission);
                qApp->postEvent(receiver, metaCallEvent);
            } else {
                void *argv[] = { nullptr, &permission };
                slotObj->call(const_cast<QObject*>(context), argv);
            }
        }
 
        if (!receiver)
            slotObj->destroyIfLastRef();
    });
}
 
#endif // QT_CONFIG(permissions)
 
#if QT_CONFIG(library)
 
Q_GLOBAL_STATIC(QRecursiveMutex, libraryPathMutex)
 
 
QStringList QCoreApplication::libraryPaths()
{
    QMutexLocker locker(libraryPathMutex());
    return libraryPathsLocked();
}
 
QStringList QCoreApplication::libraryPathsLocked()
{
    if (coreappdata()->manual_libpaths)
        return *(coreappdata()->manual_libpaths);
 
    if (!coreappdata()->app_libpaths) {
        QStringList *app_libpaths = new QStringList;
        coreappdata()->app_libpaths.reset(app_libpaths);
 
        auto setPathsFromEnv = [&](QString libPathEnv) {
            if (!libPathEnv.isEmpty()) {
                QStringList paths = libPathEnv.split(QDir::listSeparator(), Qt::SkipEmptyParts);
                for (QStringList::const_iterator it = paths.constBegin(); it != paths.constEnd(); ++it) {
                    QString canonicalPath = QDir(*it).canonicalPath();
                    if (!canonicalPath.isEmpty()
                        && !app_libpaths->contains(canonicalPath)) {
                        app_libpaths->append(canonicalPath);
                    }
                }
            }
        };
        setPathsFromEnv(qEnvironmentVariable("QT_PLUGIN_PATH"));
#ifdef Q_OS_DARWIN
        // Check the main bundle's PlugIns directory as this is a standard location for Apple OSes.
        // Note that the QLibraryInfo::PluginsPath below will coincidentally be the same as this value
        // but with a different casing, so it can't be relied upon when the underlying filesystem
        // is case sensitive (and this is always the case on newer OSes like iOS).
        if (CFBundleRef bundleRef = CFBundleGetMainBundle()) {
            if (QCFType<CFURLRef> urlRef = CFBundleCopyBuiltInPlugInsURL(bundleRef)) {
                if (QCFType<CFURLRef> absoluteUrlRef = CFURLCopyAbsoluteURL(urlRef)) {
                    if (QCFString path = CFURLCopyFileSystemPath(absoluteUrlRef, kCFURLPOSIXPathStyle)) {
                        if (QFile::exists(path)) {
                            path = QDir(path).canonicalPath();
                            if (!app_libpaths->contains(path))
                                app_libpaths->append(path);
                        }
                    }
                }
            }
        }
#endif // Q_OS_DARWIN
 
        QString installPathPlugins =  QLibraryInfo::path(QLibraryInfo::PluginsPath);
        if (QFile::exists(installPathPlugins)) {
            // Make sure we convert from backslashes to slashes.
            installPathPlugins = QDir(installPathPlugins).canonicalPath();
            if (!app_libpaths->contains(installPathPlugins))
                app_libpaths->append(installPathPlugins);
        }
 
        // If QCoreApplication is not yet instantiated,
        // make sure we add the application path when we construct the QCoreApplication
        if (self) self->d_func()->appendApplicationPathToLibraryPaths();
    }
    return *(coreappdata()->app_libpaths);
}
 
 
 
void QCoreApplication::setLibraryPaths(const QStringList &paths)
{
    QMutexLocker locker(libraryPathMutex());
 
    // setLibraryPaths() is considered a "remove everything and then add some new ones" operation.
    // When the application is constructed it should still amend the paths. So we keep the originals
    // around, and even create them if they don't exist, yet.
    if (!coreappdata()->app_libpaths)
        libraryPathsLocked();
 
    if (coreappdata()->manual_libpaths)
        *(coreappdata()->manual_libpaths) = paths;
    else
        coreappdata()->manual_libpaths.reset(new QStringList(paths));
 
    locker.unlock();
    QFactoryLoader::refreshAll();
}
 
void QCoreApplication::addLibraryPath(const QString &path)
{
    if (path.isEmpty())
        return;
 
    QString canonicalPath = QDir(path).canonicalPath();
    if (canonicalPath.isEmpty())
        return;
 
    QMutexLocker locker(libraryPathMutex());
 
    QStringList *libpaths = coreappdata()->manual_libpaths.get();
    if (libpaths) {
        if (libpaths->contains(canonicalPath))
            return;
    } else {
        // make sure that library paths are initialized
        libraryPathsLocked();
        QStringList *app_libpaths = coreappdata()->app_libpaths.get();
        if (app_libpaths->contains(canonicalPath))
            return;
 
        coreappdata()->manual_libpaths.reset(libpaths = new QStringList(*app_libpaths));
    }
 
    libpaths->prepend(canonicalPath);
    locker.unlock();
    QFactoryLoader::refreshAll();
}
 
void QCoreApplication::removeLibraryPath(const QString &path)
{
    if (path.isEmpty())
        return;
 
    QString canonicalPath = QDir(path).canonicalPath();
    if (canonicalPath.isEmpty())
        return;
 
    QMutexLocker locker(libraryPathMutex());
 
    QStringList *libpaths = coreappdata()->manual_libpaths.get();
    if (libpaths) {
        if (libpaths->removeAll(canonicalPath) == 0)
            return;
    } else {
        // make sure that library paths is initialized
        libraryPathsLocked();
        QStringList *app_libpaths = coreappdata()->app_libpaths.get();
        if (!app_libpaths->contains(canonicalPath))
            return;
 
        coreappdata()->manual_libpaths.reset(libpaths = new QStringList(*app_libpaths));
        libpaths->removeAll(canonicalPath);
    }
 
    locker.unlock();
    QFactoryLoader::refreshAll();
}
 
#endif // QT_CONFIG(library)
 
#ifndef QT_NO_QOBJECT
 
void QCoreApplication::installNativeEventFilter(QAbstractNativeEventFilter *filterObj)
{
    if (QCoreApplication::testAttribute(Qt::AA_PluginApplication)) {
        qWarning("Native event filters are not applied when the Qt::AA_PluginApplication attribute is set");
        return;
    }
 
    QAbstractEventDispatcher *eventDispatcher = QAbstractEventDispatcher::instance(QCoreApplicationPrivate::theMainThread.loadAcquire());
    if (!filterObj || !eventDispatcher)
        return;
    eventDispatcher->installNativeEventFilter(filterObj);
}
 
void QCoreApplication::removeNativeEventFilter(QAbstractNativeEventFilter *filterObject)
{
    QAbstractEventDispatcher *eventDispatcher = QAbstractEventDispatcher::instance();
    if (!filterObject || !eventDispatcher)
        return;
    eventDispatcher->removeNativeEventFilter(filterObject);
}
 
QAbstractEventDispatcher *QCoreApplication::eventDispatcher()
{
    if (QCoreApplicationPrivate::theMainThread.loadAcquire())
        return QCoreApplicationPrivate::theMainThread.loadRelaxed()->eventDispatcher();
    return nullptr;
}
 
void QCoreApplication::setEventDispatcher(QAbstractEventDispatcher *eventDispatcher)
{
    QThread *mainThread = QCoreApplicationPrivate::theMainThread.loadAcquire();
    if (!mainThread)
        mainThread = QThread::currentThread(); // will also setup theMainThread
    mainThread->setEventDispatcher(eventDispatcher);
}
 
#endif // QT_NO_QOBJECT
 
void *QCoreApplication::resolveInterface(const char *name, int revision) const
{
    Q_UNUSED(name); Q_UNUSED(revision);
    return nullptr;
}
 
QT_END_NAMESPACE
 
#ifndef QT_NO_QOBJECT
#include "moc_qcoreapplication.cpp"
#endif