Revision control
++ // Copyright (C) 2021 The Qt Company Ltd.
++ // Copyright (C) 2017 Intel Corporation.
++ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
++ // Qt-Security score:significant reason:default
++
++ #include "qplatformdefs.h"
++ #include "qstring.h"
++ #include "qbytearrayview.h"
++ #include "qlist.h"
++ #include "qdir.h"
++ #include "qdatetime.h"
++ #include <private/qlocale_tools_p.h>
++ #include "qnativeinterface.h"
++ #include "qnativeinterface_p.h"
++
++ #ifdef Q_OS_WIN
++ # include <qt_windows.h>
++ #endif
++
++ #if defined(Q_OS_VXWORKS) && defined(_WRS_KERNEL)
++ # include <envLib.h>
++ #endif
++
++ #if defined(Q_OS_INTEGRITY)
++ extern "C" {
++ // Function mmap resides in libshm_client.a. To be able to link with it one needs
++ // to define symbols 'shm_area_password' and 'shm_area_name', because the library
++ // is meant to allow the application that links to it to use POSIX shared memory
++ // without full system POSIX.
++ # pragma weak shm_area_password
++ # pragma weak shm_area_name
++ char shm_area_password[] = "dummy";
++ char shm_area_name[] = "dummy";
++ }
++ #endif
++
++ QT_BEGIN_NAMESPACE
++
++ using namespace Qt::StringLiterals;
++
++ /*!
++ \headerfile <QtGlobal>
++ \inmodule QtCore
++ \title Global Qt Declarations
++ \ingroup funclists
++
++ \brief The <QtGlobal> header file includes an assortment of other headers.
++
++ Up to Qt 6.5, most Qt header files included <QtGlobal>. Before Qt 6.5,
++ <QtGlobal> defined an assortment of global declarations. Most of these
++ have moved, at Qt 6.5, to separate headers, so that source code can
++ include only what it needs, rather than the whole assortment. For now,
++ <QtGlobal> includes those other headers (see next section), but future
++ releases of Qt may remove some of these headers from <QtGlobal> or
++ condition their inclusion on a version check. Likewise, in future
++ releases, some Qt headers that currently include <QtGlobal> may stop
++ doing so. The hope is that this will improve compilation times by
++ avoiding global declarations when they are not used.
++
++ \section1 List of Headers Extracted from <QtGlobal>
++
++ \table
++ \header \li Header \li Summary
++ \row \li <QFlags> \li Type-safe way of combining enum values
++ \row \li \l <QForeach> \li Qt's implementation of foreach and forever loops
++ \row \li \l <QFunctionPointer> \li Typedef for a pointer-to-function type
++ \row \li \l <QApplicationStatic> \li For Q_APPLICATION_STATIC
++ \row \li <QGlobalStatic> \li Thread-safe initialization of global static objects
++ \row \li \l <QOverload> \li Helpers for resolving member function overloads
++ \row \li <QSysInfo> \li A helper class to get system information
++ \row \li \l <QTypeInfo> \li Helpers to get type information
++ \row \li \l <QtAssert> \li Q_ASSERT and other runtime checks
++ \row \li \l <QtClassHelperMacros> \li Qt class helper macros
++ \row \li \l <QtCompilerDetection> \li Compiler-specific macro definitions
++ \row \li \l <QtDeprecationMarkers> \li Deprecation helper macros
++ \row \li \l <QtEnvironmentVariables> \li Helpers for working with environment variables
++ \row \li <QtExceptionHandling> \li Helpers for exception handling
++ \row \li \l <QtLogging> \li Qt logging helpers
++ \row \li <QtMalloc> \li Memory allocation helpers
++ \row \li \l <QtMinMax> \li Helpers for comparing values
++ \row \li \l <QtNumeric> \li Various numeric functions
++ \row \li \l <QtPreprocessorSupport> \li Helper preprocessor macros
++ \row \li \l <QtProcessorDetection> \li Architecture-specific macro definitions
++ \row \li \l <QtResource> \li Helpers for initializing and cleaning resources
++ \row \li \l <QtSwap> \li Implementation of qSwap()
++ \row \li \l <QtSystemDetection> \li Platform-specific macro definitions
++ \row \li \l <QtTranslation> \li Qt translation helpers
++ \row \li \l <QtTypeTraits> \li Qt type traits
++ \row \li \l <QtTypes> \li Qt fundamental type declarations
++ \row \li \l <QtVersionChecks> \li QT_VERSION_CHECK and related checks
++ \row \li \l <QtVersion> \li QT_VERSION_STR and qVersion()
++ \endtable
++ */
++
++ /*
++ Dijkstra's bisection algorithm to find the square root of an integer.
++ Deliberately not exported as part of the Qt API, but used in
++ qtextdocument.cpp.
++ */
++ Q_CORE_EXPORT Q_DECL_CONST_FUNCTION unsigned int qt_int_sqrt(unsigned int n)
++ {
++ // n must be in the range 0...UINT_MAX/2-1
++ if (n >= (UINT_MAX >> 2)) {
++ unsigned int r = 2 * qt_int_sqrt(n / 4);
++ unsigned int r2 = r + 1;
++ return (n >= r2 * r2) ? r2 : r;
++ }
++ uint h, p = 0, q = 1, r = n;
++ while (q <= n)
++ q <<= 2;
++ while (q != 1) {
++ q >>= 2;
++ h = p + q;
++ p >>= 1;
++ if (r >= h) {
++ p += q;
++ r -= h;
++ }
++ }
++ return p;
++ }
++
++ // Also specified to behave as if they call tzset():
++ // localtime() -- but not localtime_r(), which we use when threaded
++ // strftime() -- not used (except in tests)
++
++ struct QInternal_CallBackTable
++ {
++ QList<QList<qInternalCallback>> callbacks;
++ };
++
++ Q_GLOBAL_STATIC(QInternal_CallBackTable, global_callback_table)
++
++ bool QInternal::registerCallback(Callback cb, qInternalCallback callback)
++ {
++ if (unsigned(cb) < unsigned(QInternal::LastCallback)) {
++ QInternal_CallBackTable *cbt = global_callback_table();
++ cbt->callbacks.resize(cb + 1);
++ cbt->callbacks[cb].append(callback);
++ return true;
++ }
++ return false;
++ }
++
++ bool QInternal::unregisterCallback(Callback cb, qInternalCallback callback)
++ {
++ if (unsigned(cb) < unsigned(QInternal::LastCallback)) {
++ if (global_callback_table.exists()) {
++ QInternal_CallBackTable *cbt = global_callback_table();
++ return cbt->callbacks[cb].removeAll(callback) > 0;
++ }
++ }
++ return false;
++ }
++
++ bool QInternal::activateCallbacks(Callback cb, void **parameters)
++ {
++ Q_ASSERT_X(cb >= 0, "QInternal::activateCallback()", "Callback id must be a valid id");
++
++ if (!global_callback_table.exists())
++ return false;
++
++ QInternal_CallBackTable *cbt = &(*global_callback_table);
++ if (cbt && cb < cbt->callbacks.size()) {
++ QList<qInternalCallback> callbacks = cbt->callbacks[cb];
++ bool ret = false;
++ for (int i = 0; i < callbacks.size(); ++i)
++ ret |= (callbacks.at(i))(parameters);
++ return ret;
++ }
++ return false;
++ }
++
++ /*!
++ \macro QT_NO_KEYWORDS
++ \relates <QtGlobal>
++
++ Define this macro to disable the Qt-specific keywords that are usually enabled,
++ such as \c signals and \c slots. Use \c Q_SIGNALS and \c Q_SLOTS instead.
++
++ Libraries should define this macro to make sure that they don't use the generic
++ keywords without the \c Q_ prefix in their public headers.
++
++ \sa QT_NO_FOREACH
++ */
++
++ /*!
++ \macro QT_NAMESPACE
++ \internal
++
++ If this macro is defined to \c ns all Qt classes are put in a namespace
++ called \c ns. Also, moc will output code putting metaobjects etc.
++ into namespace \c ns.
++
++ \sa QT_BEGIN_NAMESPACE, QT_END_NAMESPACE,
++ QT_PREPEND_NAMESPACE, QT_USE_NAMESPACE,
++ QT_BEGIN_INCLUDE_NAMESPACE, QT_END_INCLUDE_NAMESPACE,
++ QT_BEGIN_MOC_NAMESPACE, QT_END_MOC_NAMESPACE,
++ */
++
++ /*!
++ \macro QT_PREPEND_NAMESPACE(identifier)
++ \internal
++
++ This macro qualifies \a identifier with the full namespace.
++ It expands to \c{::QT_NAMESPACE::identifier} if \c QT_NAMESPACE is defined
++ and only \a identifier otherwise.
++
++ \sa QT_NAMESPACE
++ */
++
++ /*!
++ \macro QT_USE_NAMESPACE
++ \internal
++
++ This macro expands to using QT_NAMESPACE if QT_NAMESPACE is defined
++ and nothing otherwise.
++
++ \sa QT_NAMESPACE
++ */
++
++ /*!
++ \macro QT_BEGIN_NAMESPACE
++ \internal
++
++ This macro expands to
++
++ \snippet code/src_corelib_global_qglobal.cpp begin namespace macro
++
++ if \c QT_NAMESPACE is defined and nothing otherwise. If should always
++ appear in the file-level scope and be followed by \c QT_END_NAMESPACE
++ at the same logical level with respect to preprocessor conditionals
++ in the same file.
++
++ As a rule of thumb, \c QT_BEGIN_NAMESPACE should appear in all Qt header
++ and Qt source files after the last \c{#include} line and before the first
++ declaration.
++
++ If that rule can't be followed because, e.g., \c{#include} lines and
++ declarations are wildly mixed, place \c QT_BEGIN_NAMESPACE before
++ the first declaration and wrap the \c{#include} lines in
++ \c QT_BEGIN_INCLUDE_NAMESPACE and \c QT_END_INCLUDE_NAMESPACE.
++
++ When using the \c QT_NAMESPACE feature in user code
++ (e.g., when building plugins statically linked to Qt) where
++ the user code is not intended to go into the \c QT_NAMESPACE
++ namespace, all forward declarations of Qt classes need to
++ be wrapped in \c QT_BEGIN_NAMESPACE and \c QT_END_NAMESPACE.
++ After that, a \c QT_USE_NAMESPACE should follow.
++ No further changes should be needed.
++
++ \sa QT_NAMESPACE
++ */
++
++ /*!
++ \macro QT_END_NAMESPACE
++ \internal
++
++ This macro expands to
++
++ \snippet code/src_corelib_global_qglobal.cpp end namespace macro
++
++ if \c QT_NAMESPACE is defined and nothing otherwise. It is used to cancel
++ the effect of \c QT_BEGIN_NAMESPACE.
++
++ If a source file ends with a \c{#include} directive that includes a moc file,
++ \c QT_END_NAMESPACE should be placed before that \c{#include}.
++
++ \sa QT_NAMESPACE
++ */
++
++ /*!
++ \macro QT_BEGIN_INCLUDE_NAMESPACE
++ \internal
++
++ This macro is equivalent to \c QT_END_NAMESPACE.
++ It only serves as syntactic sugar and is intended
++ to be used before #include lines within a
++ \c QT_BEGIN_NAMESPACE ... \c QT_END_NAMESPACE block.
++
++ \sa QT_NAMESPACE
++ */
++
++ /*!
++ \macro QT_END_INCLUDE_NAMESPACE
++ \internal
++
++ This macro is equivalent to \c QT_BEGIN_NAMESPACE.
++ It only serves as syntactic sugar and is intended
++ to be used after #include lines within a
++ \c QT_BEGIN_NAMESPACE ... \c QT_END_NAMESPACE block.
++
++ \sa QT_NAMESPACE
++ */
++
++ /*!
++ \macro QT_BEGIN_MOC_NAMESPACE
++ \internal
++
++ This macro is output by moc at the beginning of
++ moc files. It is equivalent to \c QT_USE_NAMESPACE.
++
++ \sa QT_NAMESPACE
++ */
++
++ /*!
++ \macro QT_END_MOC_NAMESPACE
++ \internal
++
++ This macro is output by moc at the beginning of
++ moc files. It expands to nothing.
++
++ \sa QT_NAMESPACE
++ */
++
++ /*!
++ \macro qMove(x)
++ \relates <QtGlobal>
++ \deprecated [5.15]
++
++ Use \c std::move instead.
++
++ It expands to "std::move".
++
++ qMove takes an rvalue reference to its parameter \a x, and converts it to an xvalue.
++ */
++
++ /*!
++ \macro QT_ENABLE_STRICT_MODE_UP_TO
++ \relates <QtGlobal>
++ \since 6.8
++
++ Defining this macro will disable a number of Qt APIs that are
++ deemed suboptimal or dangerous.
++
++ This macro's value must be set to a Qt version, using
++ \l{QT_VERSION_CHECK}'s encoding. For instance, in order to set it
++ to Qt 6.6, define \c{QT_ENABLE_STRICT_MODE_UP_TO=0x060600}.
++ This will disable only the APIs introduced in versions up to (and
++ including) the specified Qt version.
++
++ If the \l QT_DISABLE_DEPRECATED_UP_TO macro is \e not defined,
++ then QT_ENABLE_STRICT_MODE_UP_TO will define it as well,
++ to the same value.
++
++ This macro should always be set to the minimum Qt version that
++ your project wants to support.
++
++ The APIs disabled by this macro are listed in the table below,
++ together with the minimum value to use in order to disable them.
++
++ \table
++ \header \li Version \li Disabled APIs
++ \row \li 6.0.0 \li \l{foreach-keyword}{foreach} (see \l{QT_NO_FOREACH})
++ \row \li 6.0.0 \li QString conversions towards \c{const char *} / QByteArray (see \l{QT_NO_CAST_TO_ASCII})
++ \row \li 6.0.0 \li QByteArray implicit conversions towards \c{const char *} (see \l{QT_NO_CAST_FROM_BYTEARRAY})
++ \row \li 6.0.0 \li QUrl implicit conversions from QString (see \l{QT_NO_URL_CAST_FROM_STRING})
++ \row \li 6.0.0 \li Allowing narrowing conversions in signal-slot connections (see \l{QT_NO_NARROWING_CONVERSIONS_IN_CONNECT})
++ \row \li 6.0.0 \li Java-style iterators for Qt containers
++ \row \li 6.6.0 \li The qExchange() function (see \l{QT_NO_QEXCHANGE})
++ \row \li 6.7.0 \li Overloads of QObject::connect that do not take a context object (see \l{QT_NO_CONTEXTLESS_CONNECT})
++ \row \li 6.8.0 \li The qAsConst() function (see \l{QT_NO_QASCONST})
++ \row \li 6.8.0 \li File-related I/O classes have their \c{open()} functions marked \c{[[nodiscard]]} (see \l{QT_USE_NODISCARD_FILE_OPEN})
++ \row\li 6.9.0 \li The qsnprintf() and qvnprintf() functions (see \l{QT_NO_QSNPRINTF}).
++ \row\li 6.12.0 \li The QPair type-alias and the qMakePair() function template (use \c{std::pair}/\c{std::make_pair}).
++ \row\li 6.12.0 \li Certain transitive includes in public Qt headers (include what you need yourself).
++ \row\li 6.12.0 \li Support for const QMetaObject::Connection arguments in
++ \l{QObject::disconnect(QMetaObject::Connection&)}{QObject::disconnect()}
++ (see \l{QT_NO_DISCONNECT_CONST_CONNECTION})
++ \row\li 6.12.0 \li Support for \l{The hashing function}{qHash}
++ overloads without a seed
++ (see \l{QT_NO_SINGLE_ARGUMENT_QHASH_OVERLOAD}).
++ \endtable
++
++ Moreover, individual APIs may also get disabled as part of the
++ setting of QT_DISABLE_DEPRECATED_UP_TO. Please refer to each class'
++ documentation for more details.
++
++ \sa QT_DISABLE_DEPRECATED_UP_TO, QT_NO_KEYWORDS, QT_VERSION_CHECK
++ */
++
++ Q_LOGGING_CATEGORY(lcNativeInterface, "qt.nativeinterface")
++
++ QT_END_NAMESPACE
++
++ #ifndef QT_NO_QOBJECT
++ #include "moc_qnamespace.cpp"
++ #endif