diff options
Diffstat (limited to 'src/corelib/global/qglobal.cpp')
| -rw-r--r-- | src/corelib/global/qglobal.cpp | 530 |
1 files changed, 530 insertions, 0 deletions
diff --git a/src/corelib/global/qglobal.cpp b/src/corelib/global/qglobal.cpp index 66664f0f2a..100c1eb864 100644 --- a/src/corelib/global/qglobal.cpp +++ b/src/corelib/global/qglobal.cpp @@ -1,6 +1,7 @@ /**************************************************************************** ** ** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies). +** Copyright (C) 2014 Intel Corporation ** Contact: http://www.qt-project.org/legal ** ** This file is part of the QtCore module of the Qt Toolkit. @@ -80,6 +81,17 @@ #include <private/qjni_p.h> #endif +#if defined(Q_OS_BLACKBERRY) +# include <bps/deviceinfo.h> +#endif + +#ifdef Q_OS_UNIX +#include <sys/utsname.h> +#include <private/qcore_unix_p.h> +#endif + +#include "archdetect.cpp" + QT_BEGIN_NAMESPACE #if !QT_DEPRECATED_SINCE(5, 0) @@ -1500,6 +1512,8 @@ bool qSharedBuild() Q_DECL_NOTHROW \relates <QtGlobal> Defined if the application is compiled for Alpha processors. + + \sa QSysInfo::cpuArchitecture() */ /*! @@ -1509,6 +1523,8 @@ bool qSharedBuild() Q_DECL_NOTHROW Defined if the application is compiled for ARM processors. Qt currently supports three optional ARM revisions: \l Q_PROCESSOR_ARM_V5, \l Q_PROCESSOR_ARM_V6, and \l Q_PROCESSOR_ARM_V7. + + \sa QSysInfo::cpuArchitecture() */ /*! \macro Q_PROCESSOR_ARM_V5 @@ -1516,6 +1532,8 @@ bool qSharedBuild() Q_DECL_NOTHROW Defined if the application is compiled for ARMv5 processors. The \l Q_PROCESSOR_ARM macro is also defined when Q_PROCESSOR_ARM_V5 is defined. + + \sa QSysInfo::cpuArchitecture() */ /*! \macro Q_PROCESSOR_ARM_V6 @@ -1524,6 +1542,8 @@ bool qSharedBuild() Q_DECL_NOTHROW Defined if the application is compiled for ARMv6 processors. The \l Q_PROCESSOR_ARM and \l Q_PROCESSOR_ARM_V5 macros are also defined when Q_PROCESSOR_ARM_V6 is defined. + + \sa QSysInfo::cpuArchitecture() */ /*! \macro Q_PROCESSOR_ARM_V7 @@ -1532,6 +1552,8 @@ bool qSharedBuild() Q_DECL_NOTHROW Defined if the application is compiled for ARMv7 processors. The \l Q_PROCESSOR_ARM, \l Q_PROCESSOR_ARM_V5, and \l Q_PROCESSOR_ARM_V6 macros are also defined when Q_PROCESSOR_ARM_V7 is defined. + + \sa QSysInfo::cpuArchitecture() */ /*! @@ -1539,6 +1561,8 @@ bool qSharedBuild() Q_DECL_NOTHROW \relates <QtGlobal> Defined if the application is compiled for AVR32 processors. + + \sa QSysInfo::cpuArchitecture() */ /*! @@ -1546,6 +1570,8 @@ bool qSharedBuild() Q_DECL_NOTHROW \relates <QtGlobal> Defined if the application is compiled for Blackfin processors. + + \sa QSysInfo::cpuArchitecture() */ /*! @@ -1554,6 +1580,8 @@ bool qSharedBuild() Q_DECL_NOTHROW Defined if the application is compiled for IA-64 processors. This includes all Itanium and Itanium 2 processors. + + \sa QSysInfo::cpuArchitecture() */ /*! @@ -1564,6 +1592,8 @@ bool qSharedBuild() Q_DECL_NOTHROW supports seven MIPS revisions: \l Q_PROCESSOR_MIPS_I, \l Q_PROCESSOR_MIPS_II, \l Q_PROCESSOR_MIPS_III, \l Q_PROCESSOR_MIPS_IV, \l Q_PROCESSOR_MIPS_V, \l Q_PROCESSOR_MIPS_32, and \l Q_PROCESSOR_MIPS_64. + + \sa QSysInfo::cpuArchitecture() */ /*! \macro Q_PROCESSOR_MIPS_I @@ -1571,6 +1601,8 @@ bool qSharedBuild() Q_DECL_NOTHROW Defined if the application is compiled for MIPS-I processors. The \l Q_PROCESSOR_MIPS macro is also defined when Q_PROCESSOR_MIPS_I is defined. + + \sa QSysInfo::cpuArchitecture() */ /*! \macro Q_PROCESSOR_MIPS_II @@ -1579,6 +1611,8 @@ bool qSharedBuild() Q_DECL_NOTHROW Defined if the application is compiled for MIPS-II processors. The \l Q_PROCESSOR_MIPS and \l Q_PROCESSOR_MIPS_I macros are also defined when Q_PROCESSOR_MIPS_II is defined. + + \sa QSysInfo::cpuArchitecture() */ /*! \macro Q_PROCESSOR_MIPS_32 @@ -1587,6 +1621,8 @@ bool qSharedBuild() Q_DECL_NOTHROW Defined if the application is compiled for MIPS32 processors. The \l Q_PROCESSOR_MIPS, \l Q_PROCESSOR_MIPS_I, and \l Q_PROCESSOR_MIPS_II macros are also defined when Q_PROCESSOR_MIPS_32 is defined. + + \sa QSysInfo::cpuArchitecture() */ /*! \macro Q_PROCESSOR_MIPS_III @@ -1595,6 +1631,8 @@ bool qSharedBuild() Q_DECL_NOTHROW Defined if the application is compiled for MIPS-III processors. The \l Q_PROCESSOR_MIPS, \l Q_PROCESSOR_MIPS_I, and \l Q_PROCESSOR_MIPS_II macros are also defined when Q_PROCESSOR_MIPS_III is defined. + + \sa QSysInfo::cpuArchitecture() */ /*! \macro Q_PROCESSOR_MIPS_IV @@ -1604,6 +1642,8 @@ bool qSharedBuild() Q_DECL_NOTHROW Q_PROCESSOR_MIPS, \l Q_PROCESSOR_MIPS_I, \l Q_PROCESSOR_MIPS_II, and \l Q_PROCESSOR_MIPS_III macros are also defined when Q_PROCESSOR_MIPS_IV is defined. + + \sa QSysInfo::cpuArchitecture() */ /*! \macro Q_PROCESSOR_MIPS_V @@ -1613,6 +1653,8 @@ bool qSharedBuild() Q_DECL_NOTHROW Q_PROCESSOR_MIPS, \l Q_PROCESSOR_MIPS_I, \l Q_PROCESSOR_MIPS_II, \l Q_PROCESSOR_MIPS_III, and \l Q_PROCESSOR_MIPS_IV macros are also defined when Q_PROCESSOR_MIPS_V is defined. + + \sa QSysInfo::cpuArchitecture() */ /*! \macro Q_PROCESSOR_MIPS_64 @@ -1622,6 +1664,8 @@ bool qSharedBuild() Q_DECL_NOTHROW Q_PROCESSOR_MIPS, \l Q_PROCESSOR_MIPS_I, \l Q_PROCESSOR_MIPS_II, \l Q_PROCESSOR_MIPS_III, \l Q_PROCESSOR_MIPS_IV, and \l Q_PROCESSOR_MIPS_V macros are also defined when Q_PROCESSOR_MIPS_64 is defined. + + \sa QSysInfo::cpuArchitecture() */ /*! @@ -1631,6 +1675,8 @@ bool qSharedBuild() Q_DECL_NOTHROW Defined if the application is compiled for POWER processors. Qt currently supports two Power variants: \l Q_PROCESSOR_POWER_32 and \l Q_PROCESSOR_POWER_64. + + \sa QSysInfo::cpuArchitecture() */ /*! \macro Q_PROCESSOR_POWER_32 @@ -1639,6 +1685,8 @@ bool qSharedBuild() Q_DECL_NOTHROW Defined if the application is compiled for 32-bit Power processors. The \l Q_PROCESSOR_POWER macro is also defined when Q_PROCESSOR_POWER_32 is defined. + + \sa QSysInfo::cpuArchitecture() */ /*! \macro Q_PROCESSOR_POWER_64 @@ -1647,6 +1695,8 @@ bool qSharedBuild() Q_DECL_NOTHROW Defined if the application is compiled for 64-bit Power processors. The \l Q_PROCESSOR_POWER macro is also defined when Q_PROCESSOR_POWER_64 is defined. + + \sa QSysInfo::cpuArchitecture() */ /*! @@ -1655,6 +1705,8 @@ bool qSharedBuild() Q_DECL_NOTHROW Defined if the application is compiled for S/390 processors. Qt supports one optional variant of S/390: Q_PROCESSOR_S390_X. + + \sa QSysInfo::cpuArchitecture() */ /*! \macro Q_PROCESSOR_S390_X @@ -1662,6 +1714,8 @@ bool qSharedBuild() Q_DECL_NOTHROW Defined if the application is compiled for S/390x processors. The \l Q_PROCESSOR_S390 macro is also defined when Q_PROCESSOR_S390_X is defined. + + \sa QSysInfo::cpuArchitecture() */ /*! @@ -1670,6 +1724,8 @@ bool qSharedBuild() Q_DECL_NOTHROW Defined if the application is compiled for SuperH processors. Qt currently supports one SuperH revision: \l Q_PROCESSOR_SH_4A. + + \sa QSysInfo::cpuArchitecture() */ /*! \macro Q_PROCESSOR_SH_4A @@ -1677,6 +1733,8 @@ bool qSharedBuild() Q_DECL_NOTHROW Defined if the application is compiled for SuperH 4A processors. The \l Q_PROCESSOR_SH macro is also defined when Q_PROCESSOR_SH_4A is defined. + + \sa QSysInfo::cpuArchitecture() */ /*! @@ -1685,6 +1743,8 @@ bool qSharedBuild() Q_DECL_NOTHROW Defined if the application is compiled for SPARC processors. Qt currently supports one optional SPARC revision: \l Q_PROCESSOR_SPARC_V9. + + \sa QSysInfo::cpuArchitecture() */ /*! \macro Q_PROCESSOR_SPARC_V9 @@ -1693,6 +1753,8 @@ bool qSharedBuild() Q_DECL_NOTHROW Defined if the application is compiled for SPARC V9 processors. The \l Q_PROCESSOR_SPARC macro is also defined when Q_PROCESSOR_SPARC_V9 is defined. + + \sa QSysInfo::cpuArchitecture() */ /*! @@ -1701,6 +1763,8 @@ bool qSharedBuild() Q_DECL_NOTHROW Defined if the application is compiled for x86 processors. Qt currently supports two x86 variants: \l Q_PROCESSOR_X86_32 and \l Q_PROCESSOR_X86_64. + + \sa QSysInfo::cpuArchitecture() */ /*! \macro Q_PROCESSOR_X86_32 @@ -1709,6 +1773,8 @@ bool qSharedBuild() Q_DECL_NOTHROW Defined if the application is compiled for 32-bit x86 processors. This includes all i386, i486, i586, and i686 processors. The \l Q_PROCESSOR_X86 macro is also defined when Q_PROCESSOR_X86_32 is defined. + + \sa QSysInfo::cpuArchitecture() */ /*! \macro Q_PROCESSOR_X86_64 @@ -1717,6 +1783,8 @@ bool qSharedBuild() Q_DECL_NOTHROW Defined if the application is compiled for 64-bit x86 processors. This includes all AMD64, Intel 64, and other x86_64/x64 processors. The \l Q_PROCESSOR_X86 macro is also defined when Q_PROCESSOR_X86_64 is defined. + + \sa QSysInfo::cpuArchitecture() */ /*! @@ -1928,9 +1996,471 @@ QSysInfo::WinVersion QSysInfo::windowsVersion() return winver; } +static const char *winVer_helper() +{ + switch (int(QSysInfo::WindowsVersion)) { + case QSysInfo::WV_NT: + return "NT"; + case QSysInfo::WV_2000: + return "2000"; + case QSysInfo::WV_XP: + return "XP"; + case QSysInfo::WV_2003: + return "2003"; + case QSysInfo::WV_VISTA: + return "Vista"; + case QSysInfo::WV_WINDOWS7: + return "7"; + case QSysInfo::WV_WINDOWS8: + return "8"; + case QSysInfo::WV_WINDOWS8_1: + return "8.1"; + + case QSysInfo::WV_CE: + return "CE"; + case QSysInfo::WV_CENET: + return "CENET"; + case QSysInfo::WV_CE_5: + return "CE5"; + case QSysInfo::WV_CE_6: + return "CE6"; + } + // unknown, future version + return 0; +} + const QSysInfo::WinVersion QSysInfo::WindowsVersion = QSysInfo::windowsVersion(); #endif +#if defined(Q_OS_UNIX) +# if (defined(Q_OS_LINUX) && !defined(Q_OS_ANDROID)) || defined(Q_OS_FREEBSD) +# define USE_ETC_OS_RELEASE +# endif +struct QUnixOSVersion +{ + // from uname(2) + QString sysName; + QString sysNameLower; + QString sysRelease; + +# if !defined(Q_OS_ANDROID) && !defined(Q_OS_BLACKBERRY) && !defined(Q_OS_MAC) + // from /etc/os-release or guessed + QString versionIdentifier; // ${ID}_$VERSION_ID + QString versionText; // $PRETTY_NAME +# endif +}; + +# ifdef USE_ETC_OS_RELEASE +static QString unquote(const char *begin, const char *end) +{ + if (*begin == '"') { + Q_ASSERT(end[-1] == '"'); + return QString::fromLatin1(begin + 1, end - begin - 2); + } + return QString::fromLatin1(begin, end - begin); +} + +static bool readEtcOsRelease(QUnixOSVersion &v) +{ + // we're avoiding QFile here + int fd = qt_safe_open("/etc/os-release", O_RDONLY); + if (fd == -1) + return false; + + QT_STATBUF sbuf; + if (QT_FSTAT(fd, &sbuf) == -1) { + qt_safe_close(fd); + return false; + } + + QString partialIdentifier; + QByteArray buffer(sbuf.st_size, Qt::Uninitialized); + buffer.resize(qt_safe_read(fd, buffer.data(), sbuf.st_size)); + qt_safe_close(fd); + + const char *ptr = buffer.constData(); + const char *end = buffer.constEnd(); + const char *eol; + for ( ; ptr != end; ptr = eol + 1) { + static const char idString[] = "ID="; + static const char prettyNameString[] = "PRETTY_NAME="; + static const char versionIdString[] = "VERSION_ID="; + + // find the end of the line after ptr + eol = static_cast<const char *>(memchr(ptr, '\n', end - ptr)); + if (!eol) + eol = end - 1; + + int cmp = strncmp(ptr, idString, strlen(idString)); + if (cmp < 0) + continue; + if (cmp == 0) { + ptr += strlen(idString); + QString id = unquote(ptr, eol); + if (partialIdentifier.isNull()) + partialIdentifier = id; + else + v.versionIdentifier = id + QLatin1Char('_') + partialIdentifier; + continue; + } + + cmp = strncmp(ptr, prettyNameString, strlen(prettyNameString)); + if (cmp < 0) + continue; + if (cmp == 0) { + ptr += strlen(prettyNameString); + v.versionText = unquote(ptr, eol); + continue; + } + + cmp = strncmp(ptr, versionIdString, strlen(versionIdString)); + if (cmp < 0) + continue; + if (cmp == 0) { + ptr += strlen(versionIdString); + QString id = unquote(ptr, eol); + if (partialIdentifier.isNull()) + partialIdentifier = id; + else + v.versionIdentifier = partialIdentifier + QLatin1Char('_') + id; + continue; + } + } + + return true; +} +# endif // USE_ETC_OS_RELEASE + +static QUnixOSVersion detectUnixVersion() +{ + QUnixOSVersion v; + struct utsname u; + if (uname(&u) != -1) { + v.sysName = QString::fromLatin1(u.sysname); + v.sysNameLower = v.sysName.toLower(); + v.sysRelease = QString::fromLatin1(u.release); + } else { + v.sysName = QLatin1String("Detection failed"); + // leave sysNameLower & sysRelease unset + } + +# if !defined(Q_OS_ANDROID) && !defined(Q_OS_BLACKBERRY) && !defined(Q_OS_MAC) +# ifdef USE_ETC_OS_RELEASE + if (readEtcOsRelease(v)) + return v; +# endif + + if (!v.sysNameLower.isEmpty()) { + // will produce "qnx_6.5" or "sunos_5.9" + v.versionIdentifier = v.sysNameLower + QLatin1Char('_') + v.sysRelease; + } +# endif + + return v; +} +#endif // Q_OS_UNIX + + +/*! + \since 5.4 + + Returns the architecture of the CPU that Qt was compiled for, in text + format. Note that this may not match the actual CPU that the application is + running on if there's an emulation layer or if the CPU supports multiple + architectures (like x86-64 processors supporting i386 applications). + + Values returned by this function are stable and will not change over time, + so applications can rely on the returned value as an identifier, except + that new CPU types may be added over time. + + Typical returned values are (note: list not exhaustive): + \list + \li "arm" + \li "i386" + \li "mips" + \li "x86_64" + \li "power" + \li "sparc" + \endlist + + \sa QSysInfo::fullCpuArchitecture() +*/ +QString QSysInfo::cpuArchitecture() +{ + return QStringLiteral(ARCH_PROCESSOR); +} + +/*! + \since 5.4 + + Returns the full architecture string that Qt was compiled for. This string + is useful for identifying different, incompatible builds. For example, it + can be used as an identifier to request an upgrade package from a server. + + The values returned from this function are kept stable as follows: the + mandatory components of the result will not change in future versions of + Qt, but optional suffixes may be added. + + The returned value is composed of three or more parts, separated by dashes + ("-"). They are: + + \table + \header \li Component \li Value + \row \li CPU Architecture \li The same as QSysInfo::cpuArchitecture(), such as "arm", "i386", "mips" or "x86_64" + \row \li Endianness \li "little_endian" or "big_endian" + \row \li Word size \li Whether it's a 32- or 64-bit application. Possible values are: + "llp64" (Windows 64-bit), "lp64" (Unix 64-bit), "ilp32" (32-bit) + \row \li (Optional) ABI \li Zero or more components identifying different ABIs possible in this architecture. + Currently, Qt has optional ABI components for ARM and MIPS processors: one + component is the main ABI (such as "eabi", "o32", "n32", "o64"); another is + whether the calling convention is using hardware floating point registers ("hardfloat" + is present). + \endtable + + \sa QSysInfo::cpuArchitecture() +*/ +QString QSysInfo::fullCpuArchitecture() +{ +#ifdef Q_COMPILER_UNICODE_STRINGS + // ARCH_FULL is a concatenation of strings (incl. ARCH_PROCESSOR), which breaks + // QStringLiteral on MSVC. Since the concatenation behavior we want is specified + // the same C++11 paper as the Unicode strings, we'll use that macro and hope + // that Microsoft implements the new behavior when they add support for Unicode strings. + return QStringLiteral(ARCH_FULL); +#else + return QLatin1String(ARCH_FULL); +#endif +} + +static QString unknownText() +{ + return QStringLiteral("unknown"); +} + +/*! + \since 5.4 + + Returns the type of the operating system Qt was compiled for. It's also the + operating system the application is running on, unless the host operating + system is running a form of compatibility layer. + + Values returned by this function are stable and will not change over time, + so applications can rely on the returned value as an identifier, except + that new OS types may be added over time. + + \b{Android note}: this function returns "android" for Linux systems running + Android userspace, notably when using the Bionic library. For all other + Linux systems, regardless of C library being used, it returns "linux". + + \b{BlackBerry note}: this function returns "blackberry" for QNX systems + running the BlackBerry userspace, but "qnx" for all other QNX-based + systems. + + \b{Darwin, OS X and iOS note}: this function returns "osx" for OS X + systems, "ios" for iOS systems and "darwin" in case the system could not be + determined. + + \b{FreeBSD note}: this function returns "freebsd" for systems running the + FreeBSD kernel, regardless of whether the userspace runs the traditional + BSD code or whether it's the GNU system (Debian GNU/kFreeBSD). + + \sa QFileSelector, prettyOsName() +*/ +QString QSysInfo::osType() +{ + // similar, but not identical to QFileSelectorPrivate::platformSelectors +#if defined(Q_OS_WINPHONE) + return QStringLiteral("winphone"); +#elif defined(Q_OS_WINRT) + return QStringLiteral("winrt"); +#elif defined(Q_OS_WINCE) + return QStringLiteral("wince"); +#elif defined(Q_OS_WIN) + return QStringLiteral("windows"); + +#elif defined(Q_OS_BLACKBERRY) + return QStringLiteral("blackberry"); +#elif defined(Q_OS_QNX) + return QStringLiteral("qnx"); + +#elif defined(Q_OS_ANDROID) + return QStringLiteral("android"); +#elif defined(Q_OS_LINUX) + return QStringLiteral("linux"); + +#elif defined(Q_OS_IOS) + return QStringLiteral("ios"); +#elif defined(Q_OS_OSX) + return QStringLiteral("osx"); +#elif defined(Q_OS_DARWIN) + return QStringLiteral("darwin"); + +#elif defined(Q_OS_FREEBSD_KERNEL) + return QStringLiteral("freebsd"); +#elif defined(Q_OS_UNIX) + QUnixOSVersion unixOsVersion = detectUnixVersion(); + if (!unixOsVersion.sysNameLower.isEmpty()) + return unixOsVersion.sysNameLower; +#endif + return unknownText(); +} + +/*! + \since 5.4 + + Returns the version of the host operating system in string form. For both + OS X and iOS systems, this returns just the main OS version, such as "7.1", + "10.6" and "10.7". For Windows systems, this returns the same types + detected by winVersion(), without the word "Windows". For Linux-based + systems, it will try to determine the Linux distribution and version. + + If the version could not be determined, this function returns "unknown" for + Windows and a combination of the osType() and osKernelVersion() for Unix + systems. + + \sa prettyOsName(), osKernelVersion() +*/ +QString QSysInfo::osVersion() +{ +#if defined(Q_OS_IOS) + int major = (int(MacintoshVersion) >> 4) & 0xf; + int minor = int(MacintoshVersion) & 0xf; + if (Q_LIKELY(major < 10 && minor < 10)) { + char buf[4] = { char(major + '0'), '.', char(minor + '0'), '\0' }; + return QString::fromLatin1(buf, 3); + } + return QString::number(major) + QLatin1Char('.') + QString::number(minor); +#elif defined(Q_OS_OSX) + int minor = int(MacintoshVersion) - 2; // we're not running on Mac OS 9 + Q_ASSERT(minor < 100); + char buf[] = "10.0\0"; + if (Q_LIKELY(minor < 10)) { + buf[3] += minor; + } else { + buf[3] += minor / 10; + buf[4] = '0' + minor % 10; + } + return QString::fromLatin1(buf); +#elif defined(Q_OS_WIN) + const char *version = winVer_helper(); + if (version) + return QString::fromLatin1(version).toLower(); + // fall through + +// Android and Blackberry should not fall through to the Unix code +#elif defined(Q_OS_ANDROID) + // TBD +#elif defined(Q_OS_BLACKBERRY) + deviceinfo_details_t *deviceInfo; + if (deviceinfo_get_details(&deviceInfo) == BPS_SUCCESS) { + QString bbVersion = QString::fromLatin1(deviceinfo_details_get_device_os_version(deviceInfo)); + deviceinfo_free_details(&deviceInfo); + return bbVersion; + } +#elif defined(Q_OS_UNIX) + QUnixOSVersion unixOsVersion = detectUnixVersion(); + if (!unixOsVersion.versionIdentifier.isEmpty()) + return unixOsVersion.versionIdentifier; +#endif + + // fallback + return unknownText(); +} + +/*! + \since 5.4 + + Returns a prettier form of osVersion(), containing other information like + the operating system type, codenames and other information. The result of + this function is suitable for displaying to the user, but not for long-term + storage, as the string may change with updates to Qt. + + \sa osType(), osVersion() +*/ +QString QSysInfo::prettyOsName() +{ +#if defined(Q_OS_IOS) + return QLatin1String("iOS ") + osVersion(); +#elif defined(Q_OS_OSX) + // get the known codenames + const char *basename = 0; + switch (int(MacintoshVersion)) { + case MV_CHEETAH: + case MV_PUMA: + case MV_JAGUAR: + case MV_PANTHER: + case MV_TIGER: + // This version of Qt does not run on those versions of OS X + // so this case label will never be reached + Q_UNREACHABLE(); + break; + case MV_LEOPARD: + basename = "Mac OS X Leopard ("; + break; + case MV_SNOWLEOPARD: + basename = "Mac OS X Snow Leopard ("; + break; + case MV_LION: + basename = "Mac OS X Lion ("; + break; + case MV_MOUNTAINLION: + basename = "OS X Mountain Lion ("; + break; + case MV_MAVERICKS: + basename = "OS X Mavericks ("; + break; + } + if (basename) + return QLatin1String(basename) + osVersion() + QLatin1Char(')'); + + // a future version of OS X + return QLatin1String("OS X ") + osVersion(); +#elif defined(Q_OS_WINPHONE) + return QLatin1String("Windows Phone ") + QLatin1String(winVer_helper()); +#elif defined(Q_OS_WIN) + return QLatin1String("Windows ") + QLatin1String(winVer_helper()); +#elif defined(Q_OS_ANDROID) + return QLatin1String("Android ") + osVersion(); +#elif defined(Q_OS_BLACKBERRY) + return QLatin1String("BlackBerry ") + osVersion(); +#elif defined(Q_OS_UNIX) + QUnixOSVersion unixOsVersion = detectUnixVersion(); + if (unixOsVersion.versionText.isEmpty()) + return unixOsVersion.sysName; + else + return unixOsVersion.sysName + QLatin1String(" (") + unixOsVersion.versionText + QLatin1Char(')'); +#else + return unknownText(); +#endif +} + +/*! + \since 5.4 + + Returns the release version of the operating system. On Windows, it returns + the version of the kernel, which does not match the version number of the + OS (e.g., Windows 8 has NT kernel version 6.2). On Unix systems, including + Android, BlackBerry and OS X, it returns the same as the \c{uname -r} + command would return. + + If the version could not be determined, this function may return an empty + string. + + \sa osVersion(), prettyOsName() +*/ +QString QSysInfo::osKernelVersion() +{ +#ifdef Q_OS_WINRT + // TBD + return QString(); +#elif defined(Q_OS_WIN) + const OSVERSIONINFO osver = winOsVersion(); + return QString::number(int(osver.dwMajorVersion)) + QLatin1Char('.') + QString::number(int(osver.dwMinorVersion)) + + QLatin1Char('.') + QString::number(int(osver.dwBuildNumber)); +#else + return detectUnixVersion().sysRelease; +#endif +} /*! \macro void Q_ASSERT(bool test) |