qt5base-lts/tools/configure/configureapp.cpp
Oswald Buddenhagen b71d6ac713 ensure that no license queries are made in -redo mode
implement it in configure.exe and fix it in configure.sh.

Change-Id: I30764f4cba4bad0f23bfb40ce7a2ca614e1afd71
Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2016-08-25 11:58:46 +00:00

1313 lines
49 KiB
C++

/****************************************************************************
**
** Copyright (C) 2016 The Qt Company Ltd.
** Copyright (C) 2016 Intel Corporation.
** Contact: https://www.qt.io/licensing/
**
** This file is part of the tools applications of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:GPL-EXCEPT$
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and The Qt Company. For licensing terms
** and conditions see https://www.qt.io/terms-conditions. For further
** information use the contact form at https://www.qt.io/contact-us.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3 as published by the Free Software
** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
** included in the packaging of this file. Please review the following
** information to ensure the GNU General Public License requirements will
** be met: https://www.gnu.org/licenses/gpl-3.0.html.
**
** $QT_END_LICENSE$
**
****************************************************************************/
#include "configureapp.h"
#include "environment.h"
#include "tools.h"
#include <qdir.h>
#include <qdiriterator.h>
#include <qtemporaryfile.h>
#include <qstandardpaths.h>
#include <qstack.h>
#include <qdebug.h>
#include <qfileinfo.h>
#include <qtextstream.h>
#include <qregexp.h>
#include <qhash.h>
#include <iostream>
#include <string>
#include <fstream>
#include <windows.h>
#include <conio.h>
QT_BEGIN_NAMESPACE
enum Platforms {
WINDOWS,
WINDOWS_RT,
QNX,
ANDROID,
OTHER
};
std::ostream &operator<<(std::ostream &s, const QString &val) {
s << val.toLocal8Bit().data();
return s;
}
using namespace std;
static inline void promptKeyPress()
{
cout << "(Press any key to continue...)";
if (_getch() == 3) // _Any_ keypress w/no echo(eat <Enter> for stdout)
exit(0); // Exit cleanly for Ctrl+C
}
Configure::Configure(int& argc, char** argv)
{
int i;
for (i = 1; i < argc; i++)
configCmdLine += argv[ i ];
if (configCmdLine.size() >= 2 && configCmdLine.at(0) == "-srcdir") {
sourcePath = QDir::cleanPath(configCmdLine.at(1));
sourceDir = QDir(sourcePath);
configCmdLine.erase(configCmdLine.begin(), configCmdLine.begin() + 2);
} else {
// Get the path to the executable
wchar_t module_name[MAX_PATH];
GetModuleFileName(0, module_name, sizeof(module_name) / sizeof(wchar_t));
QFileInfo sourcePathInfo = QString::fromWCharArray(module_name);
sourcePath = sourcePathInfo.absolutePath();
sourceDir = sourcePathInfo.dir();
}
buildPath = QDir::currentPath();
#if 0
const QString installPath = QString("C:\\Qt\\%1").arg(QT_VERSION_STR);
#else
const QString installPath = buildPath;
#endif
if (sourceDir != buildDir) { //shadow builds!
QDir(buildPath).mkpath("bin");
buildDir.mkpath("mkspecs");
buildDir.mkpath("config.tests");
}
dictionary[ "QT_INSTALL_PREFIX" ] = installPath;
dictionary[ "QMAKESPEC" ] = getenv("QMAKESPEC");
if (dictionary[ "QMAKESPEC" ].size() == 0) {
dictionary[ "QMAKESPEC" ] = Environment::detectQMakeSpec();
dictionary[ "QMAKESPEC_FROM" ] = "detected";
} else {
dictionary[ "QMAKESPEC_FROM" ] = "env";
}
dictionary[ "SYNCQT" ] = "auto";
//Only used when cross compiling.
dictionary[ "QT_INSTALL_SETTINGS" ] = "/etc/xdg";
QString version;
QFile qmake_conf(sourcePath + "/.qmake.conf");
if (qmake_conf.open(QFile::ReadOnly)) {
while (!qmake_conf.atEnd()) {
static const char beginning[] = "MODULE_VERSION = ";
QByteArray line = qmake_conf.readLine();
if (!line.startsWith(beginning))
continue;
version = qMove(line).mid(int(strlen(beginning))).trimmed();
break;
}
qmake_conf.close();
}
if (version.isEmpty())
version = QString("%1.%2.%3").arg(QT_VERSION>>16).arg(((QT_VERSION>>8)&0xff)).arg(QT_VERSION&0xff);
dictionary[ "VERSION" ] = version;
{
QRegExp version_re("([0-9]*)\\.([0-9]*)\\.([0-9]*)(|-.*)");
if (version_re.exactMatch(version)) {
dictionary[ "VERSION_MAJOR" ] = version_re.cap(1);
dictionary[ "VERSION_MINOR" ] = version_re.cap(2);
dictionary[ "VERSION_PATCH" ] = version_re.cap(3);
}
}
dictionary[ "REDO" ] = "no";
dictionary[ "BUILDTYPE" ] = "none";
QString tmp = dictionary[ "QMAKESPEC" ];
if (tmp.contains("\\")) {
tmp = tmp.mid(tmp.lastIndexOf("\\") + 1);
} else {
tmp = tmp.mid(tmp.lastIndexOf("/") + 1);
}
dictionary[ "QMAKESPEC" ] = tmp;
}
Configure::~Configure()
{
}
QString Configure::formatPath(const QString &path)
{
QString ret = QDir::cleanPath(path);
// This amount of quoting is deemed sufficient.
if (ret.contains(QLatin1Char(' '))) {
ret.prepend(QLatin1Char('"'));
ret.append(QLatin1Char('"'));
}
return ret;
}
// #### somehow I get a compiler error about vc++ reaching the nesting limit without
// undefining the ansi for scoping.
#ifdef for
#undef for
#endif
void Configure::parseCmdLine()
{
sourcePathMangled = sourcePath;
buildPathMangled = buildPath;
if (configCmdLine.size() && configCmdLine.at(0) == "-top-level") {
dictionary[ "TOPLEVEL" ] = "yes";
configCmdLine.removeAt(0);
sourcePathMangled = QFileInfo(sourcePath).path();
buildPathMangled = QFileInfo(buildPath).path();
}
int argCount = configCmdLine.size();
int i = 0;
// Look first for -redo
for (int k = 0 ; k < argCount; ++k) {
if (configCmdLine.at(k) == "-redo") {
dictionary["REDO"] = "yes";
configCmdLine.removeAt(k);
if (!reloadCmdLine(k)) {
dictionary["DONE"] = "error";
return;
}
argCount = configCmdLine.size();
break;
}
}
// Then look for XQMAKESPEC
bool isDeviceMkspec = false;
for (int j = 0 ; j < argCount; ++j)
{
if ((configCmdLine.at(j) == "-xplatform") || (configCmdLine.at(j) == "-device")) {
isDeviceMkspec = (configCmdLine.at(j) == "-device");
++j;
if (j == argCount)
break;
dictionary["XQMAKESPEC"] = configCmdLine.at(j);
applySpecSpecifics();
break;
}
}
for (; i<configCmdLine.size(); ++i) {
if (configCmdLine.at(i) == "-opensource") {
dictionary[ "BUILDTYPE" ] = "opensource";
}
else if (configCmdLine.at(i) == "-commercial") {
dictionary[ "BUILDTYPE" ] = "commercial";
}
else if (configCmdLine.at(i) == "-platform") {
++i;
if (i == argCount)
break;
dictionary[ "QMAKESPEC" ] = configCmdLine.at(i);
dictionary[ "QMAKESPEC_FROM" ] = "commandline";
} else if (configCmdLine.at(i) == "-xplatform"
|| configCmdLine.at(i) == "-device") {
++i;
// do nothing
} else if (configCmdLine.at(i) == "-device-option") {
++i;
const QString option = configCmdLine.at(i);
QString &devOpt = dictionary["DEVICE_OPTION"];
if (!devOpt.isEmpty())
devOpt.append("\n").append(option);
else
devOpt = option;
}
else if (configCmdLine.at(i) == "-no-syncqt")
dictionary[ "SYNCQT" ] = "no";
else if (configCmdLine.at(i) == "-confirm-license") {
dictionary["LICENSE_CONFIRMED"] = "yes";
}
// Directories ----------------------------------------------
else if (configCmdLine.at(i) == "-prefix") {
++i;
if (i == argCount)
break;
dictionary[ "QT_INSTALL_PREFIX" ] = configCmdLine.at(i);
}
else if (configCmdLine.at(i) == "-bindir") {
++i;
if (i == argCount)
break;
dictionary[ "QT_INSTALL_BINS" ] = configCmdLine.at(i);
}
else if (configCmdLine.at(i) == "-libexecdir") {
++i;
if (i == argCount)
break;
dictionary[ "QT_INSTALL_LIBEXECS" ] = configCmdLine.at(i);
}
else if (configCmdLine.at(i) == "-libdir") {
++i;
if (i == argCount)
break;
dictionary[ "QT_INSTALL_LIBS" ] = configCmdLine.at(i);
}
else if (configCmdLine.at(i) == "-docdir") {
++i;
if (i == argCount)
break;
dictionary[ "QT_INSTALL_DOCS" ] = configCmdLine.at(i);
}
else if (configCmdLine.at(i) == "-headerdir") {
++i;
if (i == argCount)
break;
dictionary[ "QT_INSTALL_HEADERS" ] = configCmdLine.at(i);
}
else if (configCmdLine.at(i) == "-plugindir") {
++i;
if (i == argCount)
break;
dictionary[ "QT_INSTALL_PLUGINS" ] = configCmdLine.at(i);
}
else if (configCmdLine.at(i) == "-importdir") {
++i;
if (i == argCount)
break;
dictionary[ "QT_INSTALL_IMPORTS" ] = configCmdLine.at(i);
}
else if (configCmdLine.at(i) == "-qmldir") {
++i;
if (i == argCount)
break;
dictionary[ "QT_INSTALL_QML" ] = configCmdLine.at(i);
}
else if (configCmdLine.at(i) == "-archdatadir") {
++i;
if (i == argCount)
break;
dictionary[ "QT_INSTALL_ARCHDATA" ] = configCmdLine.at(i);
}
else if (configCmdLine.at(i) == "-datadir") {
++i;
if (i == argCount)
break;
dictionary[ "QT_INSTALL_DATA" ] = configCmdLine.at(i);
}
else if (configCmdLine.at(i) == "-translationdir") {
++i;
if (i == argCount)
break;
dictionary[ "QT_INSTALL_TRANSLATIONS" ] = configCmdLine.at(i);
}
else if (configCmdLine.at(i) == "-examplesdir") {
++i;
if (i == argCount)
break;
dictionary[ "QT_INSTALL_EXAMPLES" ] = configCmdLine.at(i);
}
else if (configCmdLine.at(i) == "-testsdir") {
++i;
if (i == argCount)
break;
dictionary[ "QT_INSTALL_TESTS" ] = configCmdLine.at(i);
}
else if (configCmdLine.at(i) == "-sysroot") {
++i;
if (i == argCount)
break;
dictionary[ "CFG_SYSROOT" ] = configCmdLine.at(i);
}
else if (configCmdLine.at(i) == "-hostprefix") {
++i;
if (i == argCount || configCmdLine.at(i).startsWith('-'))
dictionary[ "QT_HOST_PREFIX" ] = buildPath;
else
dictionary[ "QT_HOST_PREFIX" ] = configCmdLine.at(i);
}
else if (configCmdLine.at(i) == "-hostbindir") {
++i;
if (i == argCount)
break;
dictionary[ "QT_HOST_BINS" ] = configCmdLine.at(i);
}
else if (configCmdLine.at(i) == "-hostlibdir") {
++i;
if (i == argCount)
break;
dictionary[ "QT_HOST_LIBS" ] = configCmdLine.at(i);
}
else if (configCmdLine.at(i) == "-hostdatadir") {
++i;
if (i == argCount)
break;
dictionary[ "QT_HOST_DATA" ] = configCmdLine.at(i);
}
else if (configCmdLine.at(i) == "-extprefix") {
++i;
if (i == argCount)
break;
dictionary[ "QT_EXT_PREFIX" ] = configCmdLine.at(i);
}
else if (configCmdLine.at(i) == "-make-tool") {
++i;
if (i == argCount)
break;
dictionary[ "MAKE" ] = configCmdLine.at(i);
}
else if (configCmdLine.at(i) == "-sysconfdir") {
++i;
if (i == argCount)
break;
dictionary["QT_INSTALL_SETTINGS"] = configCmdLine.at(i);
}
else if (configCmdLine.at(i) == "-android-ndk") {
++i;
if (i == argCount)
break;
dictionary[ "ANDROID_NDK_ROOT" ] = configCmdLine.at(i);
}
else if (configCmdLine.at(i) == "-android-sdk") {
++i;
if (i == argCount)
break;
dictionary[ "ANDROID_SDK_ROOT" ] = configCmdLine.at(i);
}
else if (configCmdLine.at(i) == "-android-ndk-platform") {
++i;
if (i == argCount)
break;
dictionary[ "ANDROID_PLATFORM" ] = configCmdLine.at(i);
}
else if (configCmdLine.at(i) == "-android-ndk-host") {
++i;
if (i == argCount)
break;
dictionary[ "ANDROID_HOST" ] = configCmdLine.at(i);
}
else if (configCmdLine.at(i) == "-android-arch") {
++i;
if (i == argCount)
break;
dictionary[ "ANDROID_TARGET_ARCH" ] = configCmdLine.at(i);
}
else if (configCmdLine.at(i) == "-android-toolchain-version") {
++i;
if (i == argCount)
break;
dictionary[ "ANDROID_NDK_TOOLCHAIN_VERSION" ] = configCmdLine.at(i);
}
else if (configCmdLine.at(i) == "-no-android-style-assets") {
dictionary[ "ANDROID_STYLE_ASSETS" ] = "no";
} else if (configCmdLine.at(i) == "-android-style-assets") {
dictionary[ "ANDROID_STYLE_ASSETS" ] = "yes";
}
}
// Ensure that QMAKESPEC exists in the mkspecs folder
const QString mkspecPath(sourcePath + "/mkspecs");
QDirIterator itMkspecs(mkspecPath, QDir::AllDirs | QDir::NoDotAndDotDot, QDirIterator::Subdirectories);
QStringList mkspecs;
while (itMkspecs.hasNext()) {
QString mkspec = itMkspecs.next();
// Remove base PATH
mkspec.remove(0, mkspecPath.length() + 1);
mkspecs << mkspec;
}
if (dictionary["QMAKESPEC"].toLower() == "features"
|| !mkspecs.contains(dictionary["QMAKESPEC"], Qt::CaseInsensitive)) {
dictionary[ "DONE" ] = "error";
if (dictionary ["QMAKESPEC_FROM"] == "commandline") {
cout << "Invalid option \"" << dictionary["QMAKESPEC"] << "\" for -platform." << endl;
} else if (dictionary ["QMAKESPEC_FROM"] == "env") {
cout << "QMAKESPEC environment variable is set to \"" << dictionary["QMAKESPEC"]
<< "\" which is not a supported platform" << endl;
} else { // was autodetected from environment
cout << "Unable to detect the platform from environment. Use -platform command line" << endl
<< "argument or set the QMAKESPEC environment variable and run configure again." << endl;
}
cout << "See the README file for a list of supported operating systems and compilers." << endl;
} else {
if (dictionary[ "QMAKESPEC" ].endsWith("-icc") ||
dictionary[ "QMAKESPEC" ].endsWith("-msvc2012") ||
dictionary[ "QMAKESPEC" ].endsWith("-msvc2013") ||
dictionary[ "QMAKESPEC" ].endsWith("-msvc2015")) {
if (dictionary[ "MAKE" ].isEmpty()) dictionary[ "MAKE" ] = "nmake";
dictionary[ "QMAKEMAKEFILE" ] = "Makefile.win32";
} else if (dictionary[ "QMAKESPEC" ].startsWith(QLatin1String("win32-g++"))) {
if (dictionary[ "MAKE" ].isEmpty()) dictionary[ "MAKE" ] = "mingw32-make";
dictionary[ "QMAKEMAKEFILE" ] = "Makefile.unix";
} else {
if (dictionary[ "MAKE" ].isEmpty()) dictionary[ "MAKE" ] = "make";
dictionary[ "QMAKEMAKEFILE" ] = "Makefile.win32";
}
}
if (isDeviceMkspec) {
const QStringList devices = mkspecs.filter("devices/", Qt::CaseInsensitive);
const QStringList family = devices.filter(dictionary["XQMAKESPEC"], Qt::CaseInsensitive);
if (family.isEmpty()) {
dictionary[ "DONE" ] = "error";
cout << "Error: No device matching '" << dictionary["XQMAKESPEC"] << "'." << endl;
} else if (family.size() > 1) {
dictionary[ "DONE" ] = "error";
cout << "Error: Multiple matches for device '" << dictionary["XQMAKESPEC"] << "'. Candidates are:" << endl;
foreach (const QString &device, family)
cout << "\t* " << device << endl;
} else {
Q_ASSERT(family.size() == 1);
dictionary["XQMAKESPEC"] = family.at(0);
}
} else {
// Ensure that -spec (XQMAKESPEC) exists in the mkspecs folder as well
if (dictionary.contains("XQMAKESPEC") &&
!mkspecs.contains(dictionary["XQMAKESPEC"], Qt::CaseInsensitive)) {
dictionary[ "DONE" ] = "error";
cout << "Invalid option \"" << dictionary["XQMAKESPEC"] << "\" for -xplatform." << endl;
}
}
}
/*!
Modifies the default configuration based on given -platform option.
Eg. switches to different default styles for Windows CE.
*/
void Configure::applySpecSpecifics()
{
if (platform() == ANDROID)
dictionary["ANDROID_STYLE_ASSETS"] = "yes";
}
void Configure::prepareConfigTests()
{
// Generate an empty .qmake.cache file for config.tests
QDir buildDir(buildPath);
bool success = true;
if (!buildDir.exists("config.tests"))
success = buildDir.mkdir("config.tests");
QString fileName(buildPath + "/config.tests/.qmake.cache");
QFile cacheFile(fileName);
success &= cacheFile.open(QIODevice::WriteOnly);
cacheFile.close();
if (!success) {
cout << "Failed to create file " << qPrintable(QDir::toNativeSeparators(fileName)) << endl;
dictionary[ "DONE" ] = "error";
}
}
void Configure::generateQDevicePri()
{
FileWriter deviceStream(buildPath + "/mkspecs/qdevice.pri");
if (dictionary.contains("DEVICE_OPTION")) {
const QString devoptionlist = dictionary["DEVICE_OPTION"];
const QStringList optionlist = devoptionlist.split(QStringLiteral("\n"));
foreach (const QString &entry, optionlist)
deviceStream << entry << "\n";
}
if (dictionary.contains("ANDROID_SDK_ROOT") && dictionary.contains("ANDROID_NDK_ROOT")) {
deviceStream << "android_install {" << endl;
deviceStream << " DEFAULT_ANDROID_SDK_ROOT = " << formatPath(dictionary["ANDROID_SDK_ROOT"]) << endl;
deviceStream << " DEFAULT_ANDROID_NDK_ROOT = " << formatPath(dictionary["ANDROID_NDK_ROOT"]) << endl;
if (dictionary.contains("ANDROID_HOST"))
deviceStream << " DEFAULT_ANDROID_NDK_HOST = " << dictionary["ANDROID_HOST"] << endl;
else if (QSysInfo::WordSize == 64)
deviceStream << " DEFAULT_ANDROID_NDK_HOST = windows-x86_64" << endl;
else
deviceStream << " DEFAULT_ANDROID_NDK_HOST = windows" << endl;
QString android_arch(dictionary.contains("ANDROID_TARGET_ARCH")
? dictionary["ANDROID_TARGET_ARCH"]
: QString("armeabi-v7a"));
QString android_tc_vers(dictionary.contains("ANDROID_NDK_TOOLCHAIN_VERSION")
? dictionary["ANDROID_NDK_TOOLCHAIN_VERSION"]
: QString("4.9"));
bool targetIs64Bit = android_arch == QString("arm64-v8a")
|| android_arch == QString("x86_64")
|| android_arch == QString("mips64");
QString android_platform(dictionary.contains("ANDROID_PLATFORM")
? dictionary["ANDROID_PLATFORM"]
: (targetIs64Bit ? QString("android-21") : QString("android-9")));
deviceStream << " DEFAULT_ANDROID_PLATFORM = " << android_platform << endl;
deviceStream << " DEFAULT_ANDROID_TARGET_ARCH = " << android_arch << endl;
deviceStream << " DEFAULT_ANDROID_NDK_TOOLCHAIN_VERSION = " << android_tc_vers << endl;
deviceStream << "}" << endl;
}
if (!deviceStream.flush())
dictionary[ "DONE" ] = "error";
}
QString Configure::formatConfigPath(const char *var)
{
QString val = dictionary[var];
if (QFileInfo(val).isRelative()) {
QString pfx = dictionary["QT_INSTALL_PREFIX"];
val = (val == ".") ? pfx : QDir(pfx).absoluteFilePath(val);
}
return QDir::toNativeSeparators(val);
}
void Configure::generateHeaders()
{
if (dictionary["SYNCQT"] == "auto")
dictionary["SYNCQT"] = QFile::exists(sourcePath + "/.git") ? "yes" : "no";
if (dictionary["SYNCQT"] == "yes") {
if (!QStandardPaths::findExecutable(QStringLiteral("perl.exe")).isEmpty()) {
cout << "Running syncqt..." << endl;
QStringList args;
args << "perl" << "-w";
args += sourcePath + "/bin/syncqt.pl";
args << "-version" << dictionary["VERSION"] << "-minimal" << "-module" << "QtCore";
args += sourcePath;
int retc = Environment::execute(args, QStringList(), QStringList());
if (retc) {
cout << "syncqt failed, return code " << retc << endl << endl;
dictionary["DONE"] = "error";
}
} else {
cout << "Perl not found in environment - cannot run syncqt." << endl;
dictionary["DONE"] = "error";
}
}
}
void Configure::addConfStr(int group, const QString &val)
{
confStrOffsets[group] += ' ' + QString::number(confStringOff) + ',';
confStrings[group] += " \"" + val + "\\0\"\n";
confStringOff += val.length() + 1;
}
void Configure::generateQConfigCpp()
{
QString hostSpec = dictionary["QMAKESPEC"];
QString targSpec = dictionary.contains("XQMAKESPEC") ? dictionary["XQMAKESPEC"] : hostSpec;
dictionary["CFG_SYSROOT"] = QDir::cleanPath(dictionary["CFG_SYSROOT"]);
bool qipempty = false;
if (dictionary["QT_INSTALL_PREFIX"].isEmpty())
qipempty = true;
else
dictionary["QT_INSTALL_PREFIX"] = QDir::cleanPath(dictionary["QT_INSTALL_PREFIX"]);
bool sysrootifyPrefix;
if (dictionary["QT_EXT_PREFIX"].isEmpty()) {
dictionary["QT_EXT_PREFIX"] = dictionary["QT_INSTALL_PREFIX"];
sysrootifyPrefix = !dictionary["CFG_SYSROOT"].isEmpty();
} else {
dictionary["QT_EXT_PREFIX"] = QDir::cleanPath(dictionary["QT_EXT_PREFIX"]);
sysrootifyPrefix = false;
}
bool haveHpx;
if (dictionary["QT_HOST_PREFIX"].isEmpty()) {
dictionary["QT_HOST_PREFIX"] = (sysrootifyPrefix ? dictionary["CFG_SYSROOT"] : QString())
+ dictionary["QT_INSTALL_PREFIX"];
haveHpx = false;
} else {
dictionary["QT_HOST_PREFIX"] = QDir::cleanPath(dictionary["QT_HOST_PREFIX"]);
haveHpx = true;
}
static const struct {
const char *basevar, *baseoption, *var, *option;
} varmod[] = {
{ "INSTALL_", "-prefix", "DOCS", "-docdir" },
{ "INSTALL_", "-prefix", "HEADERS", "-headerdir" },
{ "INSTALL_", "-prefix", "LIBS", "-libdir" },
{ "INSTALL_", "-prefix", "LIBEXECS", "-libexecdir" },
{ "INSTALL_", "-prefix", "BINS", "-bindir" },
{ "INSTALL_", "-prefix", "PLUGINS", "-plugindir" },
{ "INSTALL_", "-prefix", "IMPORTS", "-importdir" },
{ "INSTALL_", "-prefix", "QML", "-qmldir" },
{ "INSTALL_", "-prefix", "ARCHDATA", "-archdatadir" },
{ "INSTALL_", "-prefix", "DATA", "-datadir" },
{ "INSTALL_", "-prefix", "TRANSLATIONS", "-translationdir" },
{ "INSTALL_", "-prefix", "EXAMPLES", "-examplesdir" },
{ "INSTALL_", "-prefix", "TESTS", "-testsdir" },
{ "INSTALL_", "-prefix", "SETTINGS", "-sysconfdir" },
{ "HOST_", "-hostprefix", "BINS", "-hostbindir" },
{ "HOST_", "-hostprefix", "LIBS", "-hostlibdir" },
{ "HOST_", "-hostprefix", "DATA", "-hostdatadir" },
};
bool prefixReminder = false;
for (uint i = 0; i < sizeof(varmod) / sizeof(varmod[0]); i++) {
QString path = QDir::cleanPath(
dictionary[QLatin1String("QT_") + varmod[i].basevar + varmod[i].var]);
if (path.isEmpty())
continue;
QString base = dictionary[QLatin1String("QT_") + varmod[i].basevar + "PREFIX"];
if (!path.startsWith(base)) {
if (i != 13) {
dictionary["PREFIX_COMPLAINTS"] += QLatin1String("\n NOTICE: ")
+ varmod[i].option + " is not a subdirectory of " + varmod[i].baseoption + ".";
if (i < 13 ? qipempty : !haveHpx)
prefixReminder = true;
}
} else {
path.remove(0, base.size());
if (path.startsWith('/'))
path.remove(0, 1);
}
dictionary[QLatin1String("QT_REL_") + varmod[i].basevar + varmod[i].var]
= path.isEmpty() ? "." : path;
}
if (prefixReminder) {
dictionary["PREFIX_COMPLAINTS"]
+= "\n Maybe you forgot to specify -prefix/-hostprefix?";
}
if (!qipempty) {
// If QT_INSTALL_* have not been specified on the command line,
// default them here, unless prefix is empty (WinCE).
if (dictionary["QT_REL_INSTALL_HEADERS"].isEmpty())
dictionary["QT_REL_INSTALL_HEADERS"] = "include";
if (dictionary["QT_REL_INSTALL_LIBS"].isEmpty())
dictionary["QT_REL_INSTALL_LIBS"] = "lib";
if (dictionary["QT_REL_INSTALL_BINS"].isEmpty())
dictionary["QT_REL_INSTALL_BINS"] = "bin";
if (dictionary["QT_REL_INSTALL_ARCHDATA"].isEmpty())
dictionary["QT_REL_INSTALL_ARCHDATA"] = ".";
if (dictionary["QT_REL_INSTALL_ARCHDATA"] != ".")
dictionary["QT_REL_INSTALL_ARCHDATA_PREFIX"] = dictionary["QT_REL_INSTALL_ARCHDATA"] + '/';
if (dictionary["QT_REL_INSTALL_LIBEXECS"].isEmpty()) {
if (targSpec.startsWith("win"))
dictionary["QT_REL_INSTALL_LIBEXECS"] = dictionary["QT_REL_INSTALL_ARCHDATA_PREFIX"] + "bin";
else
dictionary["QT_REL_INSTALL_LIBEXECS"] = dictionary["QT_REL_INSTALL_ARCHDATA_PREFIX"] + "libexec";
}
if (dictionary["QT_REL_INSTALL_PLUGINS"].isEmpty())
dictionary["QT_REL_INSTALL_PLUGINS"] = dictionary["QT_REL_INSTALL_ARCHDATA_PREFIX"] + "plugins";
if (dictionary["QT_REL_INSTALL_IMPORTS"].isEmpty())
dictionary["QT_REL_INSTALL_IMPORTS"] = dictionary["QT_REL_INSTALL_ARCHDATA_PREFIX"] + "imports";
if (dictionary["QT_REL_INSTALL_QML"].isEmpty())
dictionary["QT_REL_INSTALL_QML"] = dictionary["QT_REL_INSTALL_ARCHDATA_PREFIX"] + "qml";
if (dictionary["QT_REL_INSTALL_DATA"].isEmpty())
dictionary["QT_REL_INSTALL_DATA"] = ".";
if (dictionary["QT_REL_INSTALL_DATA"] != ".")
dictionary["QT_REL_INSTALL_DATA_PREFIX"] = dictionary["QT_REL_INSTALL_DATA"] + '/';
if (dictionary["QT_REL_INSTALL_DOCS"].isEmpty())
dictionary["QT_REL_INSTALL_DOCS"] = dictionary["QT_REL_INSTALL_DATA_PREFIX"] + "doc";
if (dictionary["QT_REL_INSTALL_TRANSLATIONS"].isEmpty())
dictionary["QT_REL_INSTALL_TRANSLATIONS"] = dictionary["QT_REL_INSTALL_DATA_PREFIX"] + "translations";
if (dictionary["QT_REL_INSTALL_EXAMPLES"].isEmpty())
dictionary["QT_REL_INSTALL_EXAMPLES"] = "examples";
if (dictionary["QT_REL_INSTALL_TESTS"].isEmpty())
dictionary["QT_REL_INSTALL_TESTS"] = "tests";
}
if (dictionary["QT_REL_HOST_BINS"].isEmpty())
dictionary["QT_REL_HOST_BINS"] = haveHpx ? "bin" : dictionary["QT_REL_INSTALL_BINS"];
if (dictionary["QT_REL_HOST_LIBS"].isEmpty())
dictionary["QT_REL_HOST_LIBS"] = haveHpx ? "lib" : dictionary["QT_REL_INSTALL_LIBS"];
if (dictionary["QT_REL_HOST_DATA"].isEmpty())
dictionary["QT_REL_HOST_DATA"] = haveHpx ? "." : dictionary["QT_REL_INSTALL_ARCHDATA"];
confStringOff = 0;
addConfStr(0, dictionary["QT_REL_INSTALL_DOCS"]);
addConfStr(0, dictionary["QT_REL_INSTALL_HEADERS"]);
addConfStr(0, dictionary["QT_REL_INSTALL_LIBS"]);
addConfStr(0, dictionary["QT_REL_INSTALL_LIBEXECS"]);
addConfStr(0, dictionary["QT_REL_INSTALL_BINS"]);
addConfStr(0, dictionary["QT_REL_INSTALL_PLUGINS"]);
addConfStr(0, dictionary["QT_REL_INSTALL_IMPORTS"]);
addConfStr(0, dictionary["QT_REL_INSTALL_QML"]);
addConfStr(0, dictionary["QT_REL_INSTALL_ARCHDATA"]);
addConfStr(0, dictionary["QT_REL_INSTALL_DATA"]);
addConfStr(0, dictionary["QT_REL_INSTALL_TRANSLATIONS"]);
addConfStr(0, dictionary["QT_REL_INSTALL_EXAMPLES"]);
addConfStr(0, dictionary["QT_REL_INSTALL_TESTS"]);
addConfStr(1, dictionary["CFG_SYSROOT"]);
addConfStr(1, dictionary["QT_REL_HOST_BINS"]);
addConfStr(1, dictionary["QT_REL_HOST_LIBS"]);
addConfStr(1, dictionary["QT_REL_HOST_DATA"]);
addConfStr(1, targSpec);
addConfStr(1, hostSpec);
// Generate the new qconfig.cpp file
{
FileWriter tmpStream(buildPath + "/src/corelib/global/qconfig.cpp");
tmpStream << "/* Build date */" << endl
<< "static const char qt_configure_installation [11 + 12] = \"qt_instdate=2012-12-20\";" << endl
<< endl
<< "/* Installation Info */" << endl
<< "static const char qt_configure_prefix_path_str [512 + 12] = \"qt_prfxpath=" << dictionary["QT_INSTALL_PREFIX"] << "\";" << endl
<< "#ifdef QT_BUILD_QMAKE" << endl
<< "static const char qt_configure_ext_prefix_path_str [512 + 12] = \"qt_epfxpath=" << dictionary["QT_EXT_PREFIX"] << "\";" << endl
<< "static const char qt_configure_host_prefix_path_str [512 + 12] = \"qt_hpfxpath=" << dictionary["QT_HOST_PREFIX"] << "\";" << endl
<< "#endif" << endl
<< endl
<< "static const short qt_configure_str_offsets[] = {\n"
<< " " << confStrOffsets[0] << endl
<< "#ifdef QT_BUILD_QMAKE\n"
<< " " << confStrOffsets[1] << endl
<< "#endif\n"
<< "};\n"
<< "static const char qt_configure_strs[] =\n"
<< confStrings[0] << "#ifdef QT_BUILD_QMAKE\n"
<< confStrings[1] << "#endif\n"
<< ";\n"
<< endl;
if ((platform() != WINDOWS) && (platform() != WINDOWS_RT))
tmpStream << "#define QT_CONFIGURE_SETTINGS_PATH \"" << dictionary["QT_REL_INSTALL_SETTINGS"] << "\"" << endl;
tmpStream << endl
<< "#ifdef QT_BUILD_QMAKE\n"
<< "# define QT_CONFIGURE_SYSROOTIFY_PREFIX " << (sysrootifyPrefix ? "true" : "false") << endl
<< "#endif\n\n"
<< endl
<< "#define QT_CONFIGURE_PREFIX_PATH qt_configure_prefix_path_str + 12\n"
<< "#ifdef QT_BUILD_QMAKE\n"
<< "# define QT_CONFIGURE_EXT_PREFIX_PATH qt_configure_ext_prefix_path_str + 12\n"
<< "# define QT_CONFIGURE_HOST_PREFIX_PATH qt_configure_host_prefix_path_str + 12\n"
<< "#endif\n";
if (!tmpStream.flush())
dictionary[ "DONE" ] = "error";
}
}
void Configure::buildQmake()
{
{
QStringList args;
// Build qmake
QString pwd = QDir::currentPath();
if (!QDir(buildPath).mkpath("qmake")) {
cout << "Cannot create qmake build dir." << endl;
dictionary[ "DONE" ] = "error";
return;
}
if (!QDir::setCurrent(buildPath + "/qmake")) {
cout << "Cannot enter qmake build dir." << endl;
dictionary[ "DONE" ] = "error";
return;
}
QString makefile = "Makefile";
{
QFile out(makefile);
if (out.open(QFile::WriteOnly | QFile::Text)) {
QTextStream stream(&out);
stream << "#AutoGenerated by configure.exe" << endl
<< "BUILD_PATH = .." << endl
<< "SOURCE_PATH = " << QDir::toNativeSeparators(sourcePath) << endl
<< "INC_PATH = " << QDir::toNativeSeparators(
(QFile::exists(sourcePath + "/.git") ? ".." : sourcePath)
+ "/include") << endl;
stream << "QT_VERSION = " << dictionary["VERSION"] << endl
<< "QT_MAJOR_VERSION = " << dictionary["VERSION_MAJOR"] << endl
<< "QT_MINOR_VERSION = " << dictionary["VERSION_MINOR"] << endl
<< "QT_PATCH_VERSION = " << dictionary["VERSION_PATCH"] << endl;
if (dictionary[ "QMAKESPEC" ].startsWith("win32-g++")) {
stream << "QMAKESPEC = $(SOURCE_PATH)\\mkspecs\\" << dictionary[ "QMAKESPEC" ] << endl
<< "EXTRA_CFLAGS = -DUNICODE -ffunction-sections" << endl
<< "EXTRA_CXXFLAGS = -std=c++11 -DUNICODE -ffunction-sections" << endl
<< "EXTRA_LFLAGS = -Wl,--gc-sections" << endl
<< "QTOBJS = qfilesystemengine_win.o \\" << endl
<< " qfilesystemiterator_win.o \\" << endl
<< " qfsfileengine_win.o \\" << endl
<< " qlocale_win.o \\" << endl
<< " qsettings_win.o \\" << endl
<< " qsystemlibrary.o \\" << endl
<< " registry.o" << endl
<< "QTSRCS=\"$(SOURCE_PATH)/src/corelib/io/qfilesystemengine_win.cpp\" \\" << endl
<< " \"$(SOURCE_PATH)/src/corelib/io/qfilesystemiterator_win.cpp\" \\" << endl
<< " \"$(SOURCE_PATH)/src/corelib/io/qfsfileengine_win.cpp\" \\" << endl
<< " \"$(SOURCE_PATH)/src/corelib/io/qsettings_win.cpp\" \\" << endl
<< " \"$(SOURCE_PATH)/src/corelib/tools/qlocale_win.cpp\" \\" << endl\
<< " \"$(SOURCE_PATH)/src/corelib/plugin/qsystemlibrary.cpp\" \\" << endl
<< " \"$(SOURCE_PATH)/tools/shared/windows/registry.cpp\"" << endl
<< "EXEEXT=.exe" << endl
<< "LFLAGS=-static -s -lole32 -luuid -ladvapi32 -lkernel32" << endl;
/*
** SHELL is the full path of sh.exe, unless
** 1) it is found in the current directory
** 2) it is not found at all
** 3) it is overridden on the command line with an existing file
** ... otherwise it is always sh.exe. Specifically, SHELL from the
** environment has no effect.
**
** This check will fail if SHELL is explicitly set to a not
** sh-compatible shell. This is not a problem, because configure.bat
** will not do that.
*/
stream << "ifeq ($(SHELL), sh.exe)" << endl
<< " ifeq ($(wildcard $(CURDIR)/sh.exe), )" << endl
<< " SH = 0" << endl
<< " else" << endl
<< " SH = 1" << endl
<< " endif" << endl
<< "else" << endl
<< " SH = 1" << endl
<< "endif" << endl
<< "\n"
<< "ifeq ($(SH), 1)" << endl
<< " RM_F = rm -f" << endl
<< " RM_RF = rm -rf" << endl
<< "else" << endl
<< " RM_F = del /f" << endl
<< " RM_RF = rmdir /s /q" << endl
<< "endif" << endl;
stream << "\n\n";
} else {
stream << "QMAKESPEC = " << dictionary["QMAKESPEC"] << endl;
}
stream << "\n\n";
QFile in(sourcePath + "/qmake/" + dictionary["QMAKEMAKEFILE"]);
if (in.open(QFile::ReadOnly | QFile::Text)) {
QString d = in.readAll();
//### need replaces (like configure.sh)? --Sam
stream << d << endl;
}
stream.flush();
out.close();
}
}
args += dictionary[ "MAKE" ];
args += "-f";
args += makefile;
cout << "Creating qmake..." << endl;
int exitCode = Environment::execute(args, QStringList(), QStringList());
if (exitCode) {
args.clear();
args += dictionary[ "MAKE" ];
args += "-f";
args += makefile;
args += "clean";
exitCode = Environment::execute(args, QStringList(), QStringList());
if (exitCode) {
cout << "Cleaning qmake failed, return code " << exitCode << endl << endl;
dictionary[ "DONE" ] = "error";
} else {
args.clear();
args += dictionary[ "MAKE" ];
args += "-f";
args += makefile;
exitCode = Environment::execute(args, QStringList(), QStringList());
if (exitCode) {
cout << "Building qmake failed, return code " << exitCode << endl << endl;
dictionary[ "DONE" ] = "error";
}
}
}
QDir::setCurrent(pwd);
}
// Generate qt.conf
QFile confFile(buildPath + "/bin/qt.conf");
if (confFile.open(QFile::WriteOnly | QFile::Text)) { // Truncates any existing file.
QTextStream confStream(&confFile);
confStream << "[EffectivePaths]" << endl
<< "Prefix=.." << endl;
if (sourcePath != buildPath)
confStream << "[EffectiveSourcePaths]" << endl
<< "Prefix=" << sourcePath << endl;
confStream.flush();
confFile.close();
}
}
void Configure::configure()
{
FileWriter ci(buildPath + "/config.tests/configure.cfg");
ci << "# Feature defaults set by configure command line\n"
<< "config.input.qt_edition = " << dictionary["EDITION"] << "\n"
<< "config.input.qt_licheck = " << dictionary["LICHECK"] << "\n"
<< "config.input.qt_release_date = " << dictionary["RELEASEDATE"];
if (!ci.flush()) {
dictionary[ "DONE" ] = "error";
return;
}
QStringList args;
args << buildPath + "/bin/qmake"
<< "-o" << "Makefile.cfg"
<< sourcePath + "/configure.pri"
<< "--" << configCmdLine;
if (int exitCode = Environment::execute(args, QStringList(), QStringList())) {
cout << "Qmake failed, return code " << exitCode << endl << endl;
dictionary[ "DONE" ] = "error";
}
if ((dictionary["REDO"] != "yes") && (dictionary["DONE"] != "error"))
saveCmdLine();
}
void Configure::generateMakefiles()
{
QString pwd = QDir::currentPath();
{
QStringList args;
args << buildPath + "/bin/qmake" << sourcePathMangled;
QDir::setCurrent(buildPathMangled);
if (int exitCode = Environment::execute(args, QStringList(), QStringList())) {
cout << "Qmake failed, return code " << exitCode << endl << endl;
dictionary[ "DONE" ] = "error";
}
}
QDir::setCurrent(pwd);
}
bool Configure::showLicense(QString orgLicenseFile)
{
if (dictionary["LICENSE_CONFIRMED"] == "yes") {
cout << "You have already accepted the terms of the license." << endl << endl;
return true;
}
bool showGpl2 = true;
QString licenseFile = orgLicenseFile;
QString theLicense;
if (dictionary["EDITION"] == "OpenSource") {
if (platform() != WINDOWS_RT
&& (platform() != ANDROID || dictionary["ANDROID_STYLE_ASSETS"] == "no")) {
theLicense = "GNU Lesser General Public License (LGPL) version 3\n"
"or the GNU General Public License (GPL) version 2";
} else {
theLicense = "GNU Lesser General Public License (LGPL) version 3";
showGpl2 = false;
}
} else {
// the first line of the license file tells us which license it is
QFile file(licenseFile);
if (!file.open(QFile::ReadOnly)) {
cout << "Failed to load LICENSE file" << endl;
return false;
}
theLicense = file.readLine().trimmed();
}
forever {
char accept = '?';
cout << "You are licensed to use this software under the terms of" << endl
<< "the " << theLicense << "." << endl
<< endl;
if (dictionary["EDITION"] == "OpenSource") {
cout << "Type 'L' to view the GNU Lesser General Public License version 3 (LGPLv3)." << endl;
if (showGpl2)
cout << "Type 'G' to view the GNU General Public License version 2 (GPLv2)." << endl;
} else {
cout << "Type '?' to view the " << theLicense << "." << endl;
}
cout << "Type 'y' to accept this license offer." << endl
<< "Type 'n' to decline this license offer." << endl
<< endl
<< "Do you accept the terms of the license?" << endl;
cin >> accept;
accept = tolower(accept);
if (accept == 'y') {
configCmdLine << "-confirm-license";
return true;
} else if (accept == 'n') {
return false;
} else {
if (dictionary["EDITION"] == "OpenSource") {
if (accept == 'L')
licenseFile = orgLicenseFile + "/LICENSE.LGPL3";
else
licenseFile = orgLicenseFile + "/LICENSE.GPL2";
}
// Get console line height, to fill the screen properly
int i = 0, screenHeight = 25; // default
CONSOLE_SCREEN_BUFFER_INFO consoleInfo;
HANDLE stdOut = GetStdHandle(STD_OUTPUT_HANDLE);
if (GetConsoleScreenBufferInfo(stdOut, &consoleInfo))
screenHeight = consoleInfo.srWindow.Bottom
- consoleInfo.srWindow.Top
- 1; // Some overlap for context
// Prompt the license content to the user
QFile file(licenseFile);
if (!file.open(QFile::ReadOnly)) {
cout << "Failed to load LICENSE file" << licenseFile << endl;
return false;
}
QStringList licenseContent = QString(file.readAll()).split('\n');
while (i < licenseContent.size()) {
cout << licenseContent.at(i) << endl;
if (++i % screenHeight == 0) {
promptKeyPress();
cout << "\r"; // Overwrite text above
}
}
}
}
}
void Configure::readLicense()
{
dictionary["PLATFORM NAME"] = platformName();
dictionary["LICENSE FILE"] = sourcePath;
bool openSource = false;
bool hasOpenSource = QFile::exists(dictionary["LICENSE FILE"] + "/LICENSE.LGPL3") || QFile::exists(dictionary["LICENSE FILE"] + "/LICENSE.GPL2");
if (dictionary["BUILDTYPE"] == "commercial") {
openSource = false;
} else if (dictionary["BUILDTYPE"] == "opensource") {
openSource = true;
} else if (hasOpenSource) { // No Open Source? Just display the commercial license right away
forever {
char accept = '?';
cout << "Which edition of Qt do you want to use ?" << endl;
cout << "Type 'c' if you want to use the Commercial Edition." << endl;
cout << "Type 'o' if you want to use the Open Source Edition." << endl;
cin >> accept;
accept = tolower(accept);
if (accept == 'c') {
openSource = false;
break;
} else if (accept == 'o') {
openSource = true;
break;
}
}
}
if (hasOpenSource && openSource) {
cout << endl << "This is the " << dictionary["PLATFORM NAME"] << " Open Source Edition." << endl;
dictionary["LICENSEE"] = "Open Source";
dictionary["EDITION"] = "OpenSource";
cout << endl;
if (!showLicense(dictionary["LICENSE FILE"])) {
cout << "Configuration aborted since license was not accepted";
dictionary["DONE"] = "error";
return;
}
} else if (openSource) {
cout << endl << "Cannot find the GPL license files! Please download the Open Source version of the library." << endl;
dictionary["DONE"] = "error";
return;
}
else {
Tools::checkLicense(dictionary, sourcePath, buildPath);
}
if (dictionary["BUILDTYPE"] == "none") {
if (openSource)
configCmdLine << "-opensource";
else
configCmdLine << "-commercial";
}
}
bool Configure::reloadCmdLine(int idx)
{
QFile inFile(buildPathMangled + "/config.opt");
if (!inFile.open(QFile::ReadOnly)) {
inFile.setFileName(buildPath + "/config.opt");
if (!inFile.open(QFile::ReadOnly)) {
inFile.setFileName(buildPath + "/configure.cache");
if (!inFile.open(QFile::ReadOnly)) {
cout << "No config.opt present - cannot redo configuration." << endl;
return false;
}
}
}
QTextStream inStream(&inFile);
while (!inStream.atEnd())
configCmdLine.insert(idx++, inStream.readLine().trimmed());
return true;
}
void Configure::saveCmdLine()
{
if (dictionary[ "REDO" ] != "yes") {
QFile outFile(buildPathMangled + "/config.opt");
if (outFile.open(QFile::WriteOnly | QFile::Text)) {
QTextStream outStream(&outFile);
for (QStringList::Iterator it = configCmdLine.begin(); it != configCmdLine.end(); ++it) {
outStream << (*it) << endl;
}
outStream.flush();
outFile.close();
}
}
}
bool Configure::isDone()
{
return !dictionary["DONE"].isEmpty();
}
bool Configure::isOk()
{
return (dictionary[ "DONE" ] != "error");
}
QString Configure::platformName() const
{
switch (platform()) {
default:
case WINDOWS:
return QStringLiteral("Qt for Windows");
case WINDOWS_RT:
return QStringLiteral("Qt for Windows Runtime");
case QNX:
return QStringLiteral("Qt for QNX");
case ANDROID:
return QStringLiteral("Qt for Android");
case OTHER:
return QStringLiteral("Qt for ???");
}
}
int Configure::platform() const
{
const QString xQMakeSpec = dictionary.value("XQMAKESPEC");
if ((xQMakeSpec.startsWith("winphone") || xQMakeSpec.startsWith("winrt")))
return WINDOWS_RT;
if (xQMakeSpec.contains("qnx"))
return QNX;
if (xQMakeSpec.contains("android"))
return ANDROID;
if (!xQMakeSpec.isEmpty())
return OTHER;
return WINDOWS;
}
FileWriter::FileWriter(const QString &name)
: QTextStream()
, m_name(name)
{
m_buffer.open(QIODevice::WriteOnly);
setDevice(&m_buffer);
}
bool FileWriter::flush()
{
QTextStream::flush();
QFile oldFile(m_name);
if (oldFile.open(QIODevice::ReadOnly | QIODevice::Text)) {
if (oldFile.readAll() == m_buffer.data())
return true;
oldFile.close();
}
QString dir = QFileInfo(m_name).absolutePath();
if (!QDir().mkpath(dir)) {
cout << "Cannot create directory " << qPrintable(QDir::toNativeSeparators(dir)) << ".\n";
return false;
}
QFile file(m_name + ".new");
if (file.open(QIODevice::WriteOnly | QIODevice::Text)) {
if (file.write(m_buffer.data()) == m_buffer.data().size()) {
file.close();
if (file.error() == QFile::NoError) {
::SetFileAttributes((wchar_t*)m_name.utf16(), FILE_ATTRIBUTE_NORMAL);
QFile::remove(m_name);
if (!file.rename(m_name)) {
cout << "Cannot replace file " << qPrintable(QDir::toNativeSeparators(m_name)) << ".\n";
return false;
}
return true;
}
}
}
cout << "Cannot create file " << qPrintable(QDir::toNativeSeparators(file.fileName()))
<< ": " << qPrintable(file.errorString()) << ".\n";
file.remove();
return false;
}
QT_END_NAMESPACE