Date: Tuesday, March 3, 2015 @ 11:49:07 Author: jgc Revision: 128603 upgpkg: subsurface 4.4.1-3
Fix build, libgit2 rebuild Added: subsurface/trunk/qt-5.4.1.patch subsurface/trunk/revert-detect.patch Modified: subsurface/trunk/PKGBUILD ---------------------+ PKGBUILD | 20 + qt-5.4.1.patch | 583 ++++++++++++++++++++++++++++++++++++++++++++++++++ revert-detect.patch | 58 ++++ 3 files changed, 656 insertions(+), 5 deletions(-) Modified: PKGBUILD =================================================================== --- PKGBUILD 2015-03-03 10:30:48 UTC (rev 128602) +++ PKGBUILD 2015-03-03 10:49:07 UTC (rev 128603) @@ -5,18 +5,28 @@ pkgname=subsurface _pkgname=Subsurface pkgver=4.4.1 -pkgrel=2 +pkgrel=3 pkgdesc='Divelog program' url='http://subsurface-divelog.org/' license=('GPL2') arch=('i686' 'x86_64') -depends=('libzip' 'libxml2' 'libxslt' 'sqlite' 'libusbx' 'libgit2' +install=install +depends=('libzip' 'libxml2' 'libxslt' 'sqlite' 'libusb' 'libgit2' 'subsurface-libdc' 'subsurface-marble') -source=("http://subsurface-divelog.org/downloads/${_pkgname}-${pkgver}.tgz";) -sha1sums=('7c33c734c59ced134f10c242c5f51b6d48cb3a0d') +source=("http://subsurface-divelog.org/downloads/${_pkgname}-${pkgver}.tgz"; + revert-detect.patch + qt-5.4.1.patch) +sha1sums=('7c33c734c59ced134f10c242c5f51b6d48cb3a0d' + '06bee56a7d1c9b93628147f27febbd07e5745e46' + '0f8ee15029561ff3cca86b937e43e6384df99218') -install=install +prepare() { + cd $_pkgname-$pkgver + patch -Np1 -R -i ../revert-detect.patch + patch -Np1 -i ../qt-5.4.1.patch +} + build() { cd "${srcdir}/${_pkgname}-${pkgver}" qmake-qt5 \ Added: qt-5.4.1.patch =================================================================== --- qt-5.4.1.patch (rev 0) +++ qt-5.4.1.patch 2015-03-03 10:49:07 UTC (rev 128603) @@ -0,0 +1,583 @@ +From 39ffb0fced85c1179af361ad77f2bd40d61deb89 Mon Sep 17 00:00:00 2001 +From: Thiago Macieira <thi...@macieira.org> +Date: Fri, 13 Feb 2015 23:49:58 -0800 +Subject: [PATCH] Fix Subsurface build with Qt 5.4.1 and later + +The intention had been all along to use the 5.4 QSysInfo API, but due to +a silly mistake in the QT_VERSION check, it never got enabled for 5.4.0. +On 5.4.1 it does get enabled and, unfortunately, causes compilation +errors because the API changed between the time we backported to +Subsurface and the final version. + +This commit backports the final QSysInfo API from Qt 5.4 into +Subsurface, which includes the renaming of a few functions. Since the +prettyOsName function no longer exists in the Qt API in that form, I've +reimplemented it using the API that does exist. + +Signed-off-by: Thiago Macieira <thi...@macieira.org> +Signed-off-by: Dirk Hohndel <d...@hohndel.org> +--- + qt-ui/usersurvey.cpp | 12 +- + subsurfacesysinfo.cpp | 361 ++++++++++++++++++++++++++++++++------------------ + subsurfacesysinfo.h | 20 +-- + 3 files changed, 252 insertions(+), 141 deletions(-) + +diff --git a/qt-ui/usersurvey.cpp b/qt-ui/usersurvey.cpp +index 4061d46..ac84869 100644 +--- a/qt-ui/usersurvey.cpp ++++ b/qt-ui/usersurvey.cpp +@@ -24,10 +24,10 @@ UserSurvey::UserSurvey(QWidget *parent) : QDialog(parent), + + os = QString("ssrfVers=%1").arg(VERSION_STRING); + os.append(QString("&prettyOsName=%1").arg(SubsurfaceSysInfo::prettyOsName())); +- QString arch = SubsurfaceSysInfo::cpuArchitecture(); ++ QString arch = SubsurfaceSysInfo::buildCpuArchitecture(); + os.append(QString("&appCpuArch=%1").arg(arch)); + if (arch == "i386") { +- QString osArch = SubsurfaceSysInfo::osArch(); ++ QString osArch = SubsurfaceSysInfo::currentCpuArchitecture(); + os.append(QString("&osCpuArch=%1").arg(osArch)); + } + os.append(QString("&uiLang=%1").arg(uiLanguage(NULL))); +@@ -41,10 +41,10 @@ QString UserSurvey::getVersion() + // fill in the system data + QString sysInfo = QString("Subsurface %1").arg(VERSION_STRING); + sysInfo.append(tr("\nOperating system: %1").arg(SubsurfaceSysInfo::prettyOsName())); +- arch = SubsurfaceSysInfo::cpuArchitecture(); ++ arch = SubsurfaceSysInfo::buildCpuArchitecture(); + sysInfo.append(tr("\nCPU architecture: %1").arg(arch)); + if (arch == "i386") +- sysInfo.append(tr("\nOS CPU architecture: %1").arg(SubsurfaceSysInfo::osArch())); ++ sysInfo.append(tr("\nOS CPU architecture: %1").arg(SubsurfaceSysInfo::currentCpuArchitecture())); + sysInfo.append(tr("\nLanguage: %1").arg(uiLanguage(NULL))); + return sysInfo; + } +@@ -56,10 +56,10 @@ QString UserSurvey::getUserAgent() + // replace all other ':' with ' ' so that this is easy to parse + QString userAgent = QString("Subsurface:%1:").arg(VERSION_STRING); + userAgent.append(SubsurfaceSysInfo::prettyOsName().replace(':', ' ') + ":"); +- arch = SubsurfaceSysInfo::cpuArchitecture().replace(':', ' '); ++ arch = SubsurfaceSysInfo::buildCpuArchitecture().replace(':', ' '); + userAgent.append(arch); + if (arch == "i386") +- userAgent.append("/" + SubsurfaceSysInfo::osArch()); ++ userAgent.append("/" + SubsurfaceSysInfo::currentCpuArchitecture()); + userAgent.append(":" + uiLanguage(NULL)); + return userAgent; + +diff --git a/subsurfacesysinfo.cpp b/subsurfacesysinfo.cpp +index f9ca282..175668c 100644 +--- a/subsurfacesysinfo.cpp ++++ b/subsurfacesysinfo.cpp +@@ -42,15 +42,19 @@ + + #include "subsurfacesysinfo.h" + #include <QString> +-#include <QFile> +-#include <QSettings> ++ ++#ifdef Q_OS_UNIX ++#include <sys/utsname.h> ++#endif ++ ++#if QT_VERSION < QT_VERSION_CHECK(5, 4, 0) + + #ifndef QStringLiteral + # define QStringLiteral QString::fromUtf8 + #endif + + #ifdef Q_OS_UNIX +-#include <sys/utsname.h> ++#include <qplatformdefs.h> + #endif + + #ifdef __APPLE__ +@@ -223,85 +227,217 @@ static const char *winVer_helper() + #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 ++# if (defined(Q_OS_LINUX) && !defined(Q_OS_ANDROID)) || defined(Q_OS_FREEBSD) ++# define USE_ETC_OS_RELEASE + 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 ++ // from /etc/os-release ++ QString productType; // $ID ++ QString productVersion; // $VERSION_ID ++ QString prettyName; // $PRETTY_NAME + }; + +- +-#ifdef USE_ETC_OS_RELEASE +-static bool readEtcOsRelease(QUnixOSVersion &v) ++static QString unquote(const char *begin, const char *end) + { +- QFile osRelease("/etc/os-release"); +- if (osRelease.exists()) { +- QSettings parse("/etc/os-release", QSettings::IniFormat); +- if (parse.contains("PRETTY_NAME")) { +- v.versionText = parse.value("PRETTY_NAME").toString(); +- } +- return true; +- } +- return false; ++ if (*begin == '"') { ++ Q_ASSERT(end[-1] == '"'); ++ return QString::fromLatin1(begin + 1, end - begin - 2); ++ } ++ return QString::fromLatin1(begin, end - begin); + } +-#endif // USE_ETC_OS_RELEASE + +-static QUnixOSVersion detectUnixVersion() ++static bool readEtcOsRelease(QUnixOSVersion &v) + { +- 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 ++ // we're avoiding QFile here ++ int fd = QT_OPEN("/etc/os-release", O_RDONLY); ++ if (fd == -1) ++ return false; ++ ++ QT_STATBUF sbuf; ++ if (QT_FSTAT(fd, &sbuf) == -1) { ++ QT_CLOSE(fd); ++ return false; + } + +-# if !defined(Q_OS_ANDROID) && !defined(Q_OS_BLACKBERRY) && !defined(Q_OS_MAC) +-# ifdef USE_ETC_OS_RELEASE +- if (readEtcOsRelease(v)) +- return v; +-# endif ++ QByteArray buffer(sbuf.st_size, Qt::Uninitialized); ++ buffer.resize(QT_READ(fd, buffer.data(), sbuf.st_size)); ++ QT_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; ++ ++ // note: we're doing a binary search here, so comparison ++ // must always be sorted ++ int cmp = strncmp(ptr, idString, strlen(idString)); ++ if (cmp < 0) ++ continue; ++ if (cmp == 0) { ++ ptr += strlen(idString); ++ v.productType = unquote(ptr, eol); ++ continue; ++ } ++ ++ cmp = strncmp(ptr, prettyNameString, strlen(prettyNameString)); ++ if (cmp < 0) ++ continue; ++ if (cmp == 0) { ++ ptr += strlen(prettyNameString); ++ v.prettyName = unquote(ptr, eol); ++ continue; ++ } + +- if (!v.sysNameLower.isEmpty()) { +- // will produce "qnx_6.5" or "sunos_5.9" +- v.versionIdentifier = v.sysNameLower + QLatin1Char('_') + v.sysRelease; ++ cmp = strncmp(ptr, versionIdString, strlen(versionIdString)); ++ if (cmp < 0) ++ continue; ++ if (cmp == 0) { ++ ptr += strlen(versionIdString); ++ v.productVersion = unquote(ptr, eol); ++ continue; ++ } + } +-# endif + +- return v; ++ return true; + } +-#endif ++# endif // USE_ETC_OS_RELEASE ++#endif // Q_OS_UNIX + + static QString unknownText() + { + return QStringLiteral("unknown"); + } + +-QString SubsurfaceSysInfo::cpuArchitecture() ++QString SubsurfaceSysInfo::buildCpuArchitecture() + { + return QStringLiteral(ARCH_PROCESSOR); + } + +-QString SubsurfaceSysInfo::fullCpuArchitecture() ++QString SubsurfaceSysInfo::currentCpuArchitecture() ++{ ++#if defined(Q_OS_WIN) && !defined(Q_OS_WINCE) ++ // We don't need to catch all the CPU architectures in this function; ++ // only those where the host CPU might be different than the build target ++ // (usually, 64-bit platforms). ++ SYSTEM_INFO info; ++ GetNativeSystemInfo(&info); ++ switch (info.wProcessorArchitecture) { ++# ifdef PROCESSOR_ARCHITECTURE_AMD64 ++ case PROCESSOR_ARCHITECTURE_AMD64: ++ return QStringLiteral("x86_64"); ++# endif ++# ifdef PROCESSOR_ARCHITECTURE_IA32_ON_WIN64 ++ case PROCESSOR_ARCHITECTURE_IA32_ON_WIN64: ++# endif ++ case PROCESSOR_ARCHITECTURE_IA64: ++ return QStringLiteral("ia64"); ++ } ++#elif defined(Q_OS_UNIX) ++ long ret = -1; ++ struct utsname u; ++ ++# if defined(Q_OS_SOLARIS) ++ // We need a special call for Solaris because uname(2) on x86 returns "i86pc" for ++ // both 32- and 64-bit CPUs. Reference: ++ // http://docs.oracle.com/cd/E18752_01/html/816-5167/sysinfo-2.html#REFMAN2sysinfo-2 ++ // http://fxr.watson.org/fxr/source/common/syscall/systeminfo.c?v=OPENSOLARIS ++ // http://fxr.watson.org/fxr/source/common/conf/param.c?v=OPENSOLARIS;im=10#L530 ++ if (ret == -1) ++ ret = sysinfo(SI_ARCHITECTURE_64, u.machine, sizeof u.machine); ++# endif ++ ++ if (ret == -1) ++ ret = uname(&u); ++ ++ // we could use detectUnixVersion() above, but we only need a field no other function does ++ if (ret != -1) { ++ // the use of QT_BUILD_INTERNAL here is simply to ensure all branches build ++ // as we don't often build on some of the less common platforms ++# if defined(Q_PROCESSOR_ARM) || defined(QT_BUILD_INTERNAL) ++ if (strcmp(u.machine, "aarch64") == 0) ++ return QStringLiteral("arm64"); ++ if (strncmp(u.machine, "armv", 4) == 0) ++ return QStringLiteral("arm"); ++# endif ++# if defined(Q_PROCESSOR_POWER) || defined(QT_BUILD_INTERNAL) ++ // harmonize "powerpc" and "ppc" to "power" ++ if (strncmp(u.machine, "ppc", 3) == 0) ++ return QLatin1String("power") + QLatin1String(u.machine + 3); ++ if (strncmp(u.machine, "powerpc", 7) == 0) ++ return QLatin1String("power") + QLatin1String(u.machine + 7); ++ if (strcmp(u.machine, "Power Macintosh") == 0) ++ return QLatin1String("power"); ++# endif ++# if defined(Q_PROCESSOR_SPARC) || defined(QT_BUILD_INTERNAL) ++ // Solaris sysinfo(2) (above) uses "sparcv9", but uname -m says "sun4u"; ++ // Linux says "sparc64" ++ if (strcmp(u.machine, "sun4u") == 0 || strcmp(u.machine, "sparc64") == 0) ++ return QStringLiteral("sparcv9"); ++ if (strcmp(u.machine, "sparc32") == 0) ++ return QStringLiteral("sparc"); ++# endif ++# if defined(Q_PROCESSOR_X86) || defined(QT_BUILD_INTERNAL) ++ // harmonize all "i?86" to "i386" ++ if (strlen(u.machine) == 4 && u.machine[0] == 'i' ++ && u.machine[2] == '8' && u.machine[3] == '6') ++ return QStringLiteral("i386"); ++ if (strcmp(u.machine, "amd64") == 0) // Solaris ++ return QStringLiteral("x86_64"); ++# endif ++ return QString::fromLatin1(u.machine); ++ } ++#endif ++ return buildCpuArchitecture(); ++} ++ ++ ++QString SubsurfaceSysInfo::buildAbi() + { + return QLatin1String(ARCH_FULL); + } + +-QString SubsurfaceSysInfo::osType() ++QString SubsurfaceSysInfo::kernelType() ++{ ++#if defined(Q_OS_WINCE) ++ return QStringLiteral("wince"); ++#elif defined(Q_OS_WIN) ++ return QStringLiteral("winnt"); ++#elif defined(Q_OS_UNIX) ++ struct utsname u; ++ if (uname(&u) == 0) ++ return QString::fromLatin1(u.sysname).toLower(); ++#endif ++ return unknownText(); ++} ++ ++QString SubsurfaceSysInfo::kernelVersion() + { ++#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 ++ struct utsname u; ++ if (uname(&u) == 0) ++ return QString::fromLatin1(u.release); ++ return QString(); ++#endif ++} ++ ++QString SubsurfaceSysInfo::productType() ++{ ++ // similar, but not identical to QFileSelectorPrivate::platformSelectors + #if defined(Q_OS_WINPHONE) + return QStringLiteral("winphone"); + #elif defined(Q_OS_WINRT) +@@ -318,8 +454,6 @@ QString SubsurfaceSysInfo::osType() + + #elif defined(Q_OS_ANDROID) + return QStringLiteral("android"); +-#elif defined(Q_OS_LINUX) +- return QStringLiteral("linux"); + + #elif defined(Q_OS_IOS) + return QStringLiteral("ios"); +@@ -328,31 +462,16 @@ QString SubsurfaceSysInfo::osType() + #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; ++#elif defined(USE_ETC_OS_RELEASE) // Q_OS_UNIX ++ QUnixOSVersion unixOsVersion; ++ readEtcOsRelease(unixOsVersion); ++ if (!unixOsVersion.productType.isEmpty()) ++ return unixOsVersion.productType; + #endif + return unknownText(); + } + +-QString SubsurfaceSysInfo::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 +-} +- +-QString SubsurfaceSysInfo::osVersion() ++QString SubsurfaceSysInfo::productVersion() + { + #if defined(Q_OS_IOS) + int major = (int(MacintoshVersion) >> 4) & 0xf; +@@ -389,24 +508,34 @@ QString SubsurfaceSysInfo::osVersion() + deviceinfo_free_details(&deviceInfo); + return bbVersion; + } +-#elif defined(Q_OS_UNIX) +- QUnixOSVersion unixOsVersion = detectUnixVersion(); +- if (!unixOsVersion.versionIdentifier.isEmpty()) +- return unixOsVersion.versionIdentifier; ++#elif defined(USE_ETC_OS_RELEASE) // Q_OS_UNIX ++ QUnixOSVersion unixOsVersion; ++ readEtcOsRelease(unixOsVersion); ++ if (!unixOsVersion.productVersion.isEmpty()) ++ return unixOsVersion.productVersion; + #endif + + // fallback + return unknownText(); + } + +-QString SubsurfaceSysInfo::prettyOsName() ++QString SubsurfaceSysInfo::prettyProductName() + { + #if defined(Q_OS_IOS) +- return QLatin1String("iOS ") + osVersion(); ++ return QLatin1String("iOS ") + productVersion(); + #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; +@@ -419,73 +548,53 @@ QString SubsurfaceSysInfo::prettyOsName() + case MV_MOUNTAINLION: + basename = "OS X Mountain Lion ("; + break; +-#ifdef MV_MAVERICKS + case MV_MAVERICKS: +-#else +- case 0x000B: // MV_MAVERICKS +-#endif + basename = "OS X Mavericks ("; + break; +-#ifdef MV_YOSEMITE + case MV_YOSEMITE: +-#else +- case 0x000C: // MV_YOSEMITE +-#endif + basename = "OS X Yosemite ("; + break; + } + if (basename) +- return QLatin1String(basename) + osVersion() + QLatin1Char(')'); ++ return QLatin1String(basename) + productVersion() + QLatin1Char(')'); + + // a future version of OS X +- return QLatin1String("OS X ") + osVersion(); ++ return QLatin1String("OS X ") + productVersion(); + #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(); ++ return QLatin1String("Android ") + productVersion(); + #elif defined(Q_OS_BLACKBERRY) +- return QLatin1String("BlackBerry ") + osVersion(); ++ return QLatin1String("BlackBerry ") + productVersion(); + #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(); ++# ifdef USE_ETC_OS_RELEASE ++ QUnixOSVersion unixOsVersion; ++ readEtcOsRelease(unixOsVersion); ++ if (!unixOsVersion.prettyName.isEmpty()) ++ return unixOsVersion.prettyName; ++# endif ++ struct utsname u; ++ if (uname(&u) == 0) ++ return QString::fromLatin1(u.sysname) + QLatin1Char(' ') + QString::fromLatin1(u.release); + #endif ++ return unknownText(); + } + +-// detect if the OS we are running on is 64 or 32bit +-// we only care when building on Intel for 32bit +-QString SubsurfaceSysInfo::osArch() ++#endif // Qt >= 5.4 ++ ++QString SubsurfaceSysInfo::prettyOsName() + { +- QString res = ""; +-#if defined(Q_PROCESSOR_X86_32) +-#if defined(Q_OS_UNIX) ++ // Matches the pre-release version of Qt 5.4 ++ QString pretty = prettyProductName(); ++#if defined(Q_OS_UNIX) && !defined(Q_OS_MAC) && !defined(Q_OS_ANDROID) ++ // QSysInfo::kernelType() returns lowercase ("linux" instead of "Linux") + struct utsname u; +- if (uname(&u) != -1) { +- res = u.machine; +- } +-#elif defined(Q_OS_WIN) +- +- /* this code is from +- * http://mark.koli.ch/reliably-checking-os-bitness-32-or-64-bit-on-windows-with-a-tiny-c-app +- * there is no license given, but 5 lines of code should be fine to reuse unless explicitly forbidden */ +- typedef BOOL (WINAPI *IW64PFP)(HANDLE, BOOL *); +- BOOL os64 = FALSE; +- IW64PFP IW64P = (IW64PFP)GetProcAddress( +- GetModuleHandle((LPCSTR)"kernel32"), "IsWow64Process"); +- +- if(IW64P != NULL){ +- IW64P(GetCurrentProcess(), &os64); +- } +- res = os64 ? "x86_64" : "i386"; +-#endif ++ if (uname(&u) == 0) ++ return QString::fromLatin1(u.sysname) + QLatin1String(" (") + pretty + QLatin1Char(')'); + #endif +- return res; ++ return pretty; + } + + extern "C" { +diff --git a/subsurfacesysinfo.h b/subsurfacesysinfo.h +index 877f7ef..23c7011 100644 +--- a/subsurfacesysinfo.h ++++ b/subsurfacesysinfo.h +@@ -205,16 +205,18 @@ + + class SubsurfaceSysInfo : public QSysInfo { + public: +-#if QT_VERSION <= 0x050400 +- static QString cpuArchitecture(); +- static QString fullCpuArchitecture(); +- static QString osType(); +- static QString osKernelVersion(); +- static QString osVersion(); +- static QString prettyOsName(); +- ++#if QT_VERSION < 0x050400 ++ static QString buildCpuArchitecture(); ++ static QString currentCpuArchitecture(); ++ static QString buildAbi(); ++ ++ static QString kernelType(); ++ static QString kernelVersion(); ++ static QString productType(); ++ static QString productVersion(); ++ static QString prettyProductName(); + #endif +- static QString osArch(); ++ static QString prettyOsName(); + }; + + +-- +1.9.1 + Added: revert-detect.patch =================================================================== --- revert-detect.patch (rev 0) +++ revert-detect.patch 2015-03-03 10:49:07 UTC (rev 128603) @@ -0,0 +1,58 @@ +From caa153af79d7650181e4fdbbef281ac1bbca4bfd Mon Sep 17 00:00:00 2001 +From: Dirk Hohndel <d...@hohndel.org> +Date: Wed, 18 Feb 2015 07:41:28 -0800 +Subject: [PATCH] Correctly detect more Linux distributions + +I don't think there's a way we can track all of the variations here, but +this supports any distribution that supports the lsb-release standard and +adds extra detection to correctly decode the PCLinuxOS version as they +neither implement /etc/os-release nor completely implement +/etc/lsb-release + +Signed-off-by: Dirk Hohndel <d...@hohndel.org> +--- + subsurfacesysinfo.cpp | 21 +++++++++++++++++++++ + 1 file changed, 21 insertions(+) + +diff --git a/subsurfacesysinfo.cpp b/subsurfacesysinfo.cpp +index 2458d28..4a55e73 100644 +--- a/subsurfacesysinfo.cpp ++++ b/subsurfacesysinfo.cpp +@@ -44,6 +44,7 @@ + #include <QString> + #include <QFile> + #include <QSettings> ++#include <QTextStream> + + #ifndef QStringLiteral + # define QStringLiteral QString::fromUtf8 +@@ -234,6 +235,26 @@ static bool readEtcOsRelease(QUnixOSVersion &v) + } + return true; + } ++ QFile lsbRelease("/etc/lsb-release"); ++ if (lsbRelease.exists()) { ++ QSettings parse("/etc/lsb-release", QSettings::IniFormat); ++ if (parse.contains("DISTRIB_DESCRIPTION")) { ++ v.versionText = parse.value("DISTRIB_DESCRIPTION").toString(); ++ if (v.versionText == "PCLinuxOS") { ++ QFile release("/etc/release"); ++ if (release.exists()) { ++ if (release.open(QFile::ReadOnly | QFile::Text)) { ++ QTextStream in(&release); ++ v.versionText = in.readAll(); ++ // need to get rid of the redundant text after '(' ++ int i = v.versionText.indexOf('('); ++ v.versionText.remove(i, 1000); ++ } ++ } ++ } ++ } ++ return true; ++ } + return false; + } + #endif // USE_ETC_OS_RELEASE +-- +1.9.1 +
