Configure::Configure(int& argc, char** argv)
{
- useUnixSeparators = false;
// Default values for indentation
optionIndent = 4;
descIndent = 25;
if (syncqt_bat.open(QFile::WriteOnly | QFile::Text)) {
QTextStream stream(&syncqt_bat);
stream << "@echo off" << endl
- << "call " << fixSeparators(sourcePath) << fixSeparators("/bin/syncqt.bat -qtdir \"") << fixSeparators(buildPath) << "\" %*" << endl;
+ << "call " << QDir::toNativeSeparators(sourcePath + "/bin/syncqt.bat")
+ << " -qtdir \"" << QDir::toNativeSeparators(buildPath) << "\" %*" << endl;
syncqt_bat.close();
}
}
}
defaultBuildParts << QStringLiteral("libs") << QStringLiteral("examples");
- dictionary[ "QT_SOURCE_TREE" ] = fixSeparators(sourcePath);
- dictionary[ "QT_BUILD_TREE" ] = fixSeparators(buildPath);
- dictionary[ "QT_INSTALL_PREFIX" ] = fixSeparators(installPath);
+ dictionary[ "QT_SOURCE_TREE" ] = sourcePath;
+ dictionary[ "QT_BUILD_TREE" ] = buildPath;
+ dictionary[ "QT_INSTALL_PREFIX" ] = installPath;
dictionary[ "QMAKESPEC" ] = getenv("QMAKESPEC");
if (dictionary[ "QMAKESPEC" ].size() == 0) {
}
}
-QString Configure::fixSeparators(const QString &somePath, bool escape)
+QString Configure::formatPath(const QString &path)
{
- if (useUnixSeparators)
- return QDir::fromNativeSeparators(somePath);
- QString ret = QDir::toNativeSeparators(somePath);
- return escape ? escapeSeparators(ret) : ret;
+ QString ret = QDir::cleanPath(path);
+ // This amount of quoting is deemed sufficient. ™
+ if (ret.contains(QLatin1Char(' '))) {
+ ret.prepend(QLatin1Char('"'));
+ ret.append(QLatin1Char('"'));
+ }
+ return ret;
}
-QString Configure::escapeSeparators(const QString &somePath)
+QString Configure::formatPaths(const QStringList &paths)
{
- QString out = somePath;
- out.replace(QLatin1Char('\\'), QLatin1String("\\\\"));
- return out;
+ QString ret;
+ foreach (const QString &path, paths) {
+ if (!ret.isEmpty())
+ ret += QLatin1Char(' ');
+ ret += formatPath(path);
+ }
+ return ret;
}
// We could use QDir::homePath() + "/.qt-license", but
}
// Ensure that QMAKESPEC exists in the mkspecs folder
- const QString mkspecPath = fixSeparators(sourcePath + "/mkspecs");
+ const QString mkspecPath(sourcePath + "/mkspecs");
QDirIterator itMkspecs(mkspecPath, QDir::AllDirs | QDir::NoDotAndDotDot, QDirIterator::Subdirectories);
QStringList mkspecs;
}
}
- useUnixSeparators = (dictionary["QMAKESPEC"] == "win32-g++");
-
// Allow tests for private classes to be compiled against internal builds
if (dictionary["BUILDDEV"] == "yes")
qtConfig += "private_tests";
qtConfig += "accessibility";
if (!qmakeLibs.isEmpty())
- qmakeVars += "LIBS += " + escapeSeparators(qmakeLibs.join(" "));
+ qmakeVars += "LIBS += " + formatPaths(qmakeLibs);
if (!dictionary["QT_LFLAGS_SQLITE"].isEmpty())
- qmakeVars += "QT_LFLAGS_SQLITE += " + escapeSeparators(dictionary["QT_LFLAGS_SQLITE"]);
+ qmakeVars += "QT_LFLAGS_SQLITE += " + formatPath(dictionary["QT_LFLAGS_SQLITE"]);
if (dictionary[ "OPENGL" ] == "yes")
qtConfig += "opengl";
qipempty = true;
if (!dictionary[ "QT_INSTALL_DOCS" ].size())
- dictionary[ "QT_INSTALL_DOCS" ] = qipempty ? "" : fixSeparators(dictionary[ "QT_INSTALL_PREFIX" ] + "/doc");
+ dictionary[ "QT_INSTALL_DOCS" ] = qipempty ? "" : dictionary[ "QT_INSTALL_PREFIX" ] + "/doc";
if (!dictionary[ "QT_INSTALL_HEADERS" ].size())
- dictionary[ "QT_INSTALL_HEADERS" ] = qipempty ? "" : fixSeparators(dictionary[ "QT_INSTALL_PREFIX" ] + "/include");
+ dictionary[ "QT_INSTALL_HEADERS" ] = qipempty ? "" : dictionary[ "QT_INSTALL_PREFIX" ] + "/include";
if (!dictionary[ "QT_INSTALL_LIBS" ].size())
- dictionary[ "QT_INSTALL_LIBS" ] = qipempty ? "" : fixSeparators(dictionary[ "QT_INSTALL_PREFIX" ] + "/lib");
+ dictionary[ "QT_INSTALL_LIBS" ] = qipempty ? "" : dictionary[ "QT_INSTALL_PREFIX" ] + "/lib";
if (!dictionary[ "QT_INSTALL_BINS" ].size())
- dictionary[ "QT_INSTALL_BINS" ] = qipempty ? "" : fixSeparators(dictionary[ "QT_INSTALL_PREFIX" ] + "/bin");
+ dictionary[ "QT_INSTALL_BINS" ] = qipempty ? "" : dictionary[ "QT_INSTALL_PREFIX" ] + "/bin";
if (!dictionary[ "QT_INSTALL_PLUGINS" ].size())
- dictionary[ "QT_INSTALL_PLUGINS" ] = qipempty ? "" : fixSeparators(dictionary[ "QT_INSTALL_PREFIX" ] + "/plugins");
+ dictionary[ "QT_INSTALL_PLUGINS" ] = qipempty ? "" : dictionary[ "QT_INSTALL_PREFIX" ] + "/plugins";
if (!dictionary[ "QT_INSTALL_IMPORTS" ].size())
- dictionary[ "QT_INSTALL_IMPORTS" ] = qipempty ? "" : fixSeparators(dictionary[ "QT_INSTALL_PREFIX" ] + "/imports");
+ dictionary[ "QT_INSTALL_IMPORTS" ] = qipempty ? "" : dictionary[ "QT_INSTALL_PREFIX" ] + "/imports";
if (!dictionary[ "QT_INSTALL_DATA" ].size())
- dictionary[ "QT_INSTALL_DATA" ] = qipempty ? "" : fixSeparators(dictionary[ "QT_INSTALL_PREFIX" ]);
+ dictionary[ "QT_INSTALL_DATA" ] = qipempty ? "" : dictionary[ "QT_INSTALL_PREFIX" ];
if (!dictionary[ "QT_INSTALL_TRANSLATIONS" ].size())
- dictionary[ "QT_INSTALL_TRANSLATIONS" ] = qipempty ? "" : fixSeparators(dictionary[ "QT_INSTALL_PREFIX" ] + "/translations");
+ dictionary[ "QT_INSTALL_TRANSLATIONS" ] = qipempty ? "" : dictionary[ "QT_INSTALL_PREFIX" ] + "/translations";
if (!dictionary[ "QT_INSTALL_EXAMPLES" ].size())
- dictionary[ "QT_INSTALL_EXAMPLES" ] = qipempty ? "" : fixSeparators(dictionary[ "QT_INSTALL_PREFIX" ] + "/examples");
+ dictionary[ "QT_INSTALL_EXAMPLES" ] = qipempty ? "" : dictionary[ "QT_INSTALL_PREFIX" ] + "/examples";
if (!dictionary[ "QT_INSTALL_TESTS" ].size())
- dictionary[ "QT_INSTALL_TESTS" ] = qipempty ? "" : fixSeparators(dictionary[ "QT_INSTALL_PREFIX" ] + "/tests");
+ dictionary[ "QT_INSTALL_TESTS" ] = qipempty ? "" : dictionary[ "QT_INSTALL_PREFIX" ] + "/tests";
bool haveHpx = false;
if (dictionary[ "QT_HOST_PREFIX" ].isEmpty())
else
haveHpx = true;
if (dictionary[ "QT_HOST_BINS" ].isEmpty())
- dictionary[ "QT_HOST_BINS" ] = haveHpx ? fixSeparators(dictionary[ "QT_HOST_PREFIX" ] + "/bin") : dictionary[ "QT_INSTALL_BINS" ];
+ dictionary[ "QT_HOST_BINS" ] = haveHpx ? dictionary[ "QT_HOST_PREFIX" ] + "/bin" : dictionary[ "QT_INSTALL_BINS" ];
if (dictionary[ "QT_HOST_DATA" ].isEmpty())
dictionary[ "QT_HOST_DATA" ] = haveHpx ? dictionary[ "QT_HOST_PREFIX" ] : dictionary[ "QT_INSTALL_DATA" ];
if (dictionary.contains("XQMAKESPEC") && dictionary[ "XQMAKESPEC" ].startsWith("linux"))
dictionary[ "QMAKE_RPATHDIR" ] = dictionary[ "QT_INSTALL_LIBS" ];
- qmakeVars += QString("OBJECTS_DIR = ") + fixSeparators("tmp/obj/" + dictionary[ "QMAKE_OUTDIR" ], true);
- qmakeVars += QString("MOC_DIR = ") + fixSeparators("tmp/moc/" + dictionary[ "QMAKE_OUTDIR" ], true);
- qmakeVars += QString("RCC_DIR = ") + fixSeparators("tmp/rcc/" + dictionary["QMAKE_OUTDIR"], true);
+ qmakeVars += QString("OBJECTS_DIR = ") + formatPath("tmp/obj/" + dictionary["QMAKE_OUTDIR"]);
+ qmakeVars += QString("MOC_DIR = ") + formatPath("tmp/moc/" + dictionary["QMAKE_OUTDIR"]);
+ qmakeVars += QString("RCC_DIR = ") + formatPath("tmp/rcc/" + dictionary["QMAKE_OUTDIR"]);
if (!qmakeDefines.isEmpty())
qmakeVars += QString("DEFINES += ") + qmakeDefines.join(" ");
if (!qmakeIncludes.isEmpty())
- qmakeVars += QString("INCLUDEPATH += ") + escapeSeparators(qmakeIncludes.join(" "));
+ qmakeVars += QString("INCLUDEPATH += ") + formatPaths(qmakeIncludes);
if (!opensslLibs.isEmpty())
qmakeVars += opensslLibs;
else if (dictionary[ "OPENSSL" ] == "linked")
{
QStringList lflagsTDS;
if (!sybase.isEmpty())
- lflagsTDS += QString("-L") + fixSeparators(sybase.section("=", 1) + "/lib");
+ lflagsTDS += QString("-L") + formatPath(sybase.section("=", 1) + "/lib");
if (!sybaseLibs.isEmpty())
lflagsTDS += sybaseLibs.section("=", 1);
if (!lflagsTDS.isEmpty())
QTextStream moduleStream(&moduleFile);
moduleStream << "#paths" << endl;
- moduleStream << "QT_BUILD_TREE = " << fixSeparators(dictionary[ "QT_BUILD_TREE" ], true) << endl;
- moduleStream << "QT_SOURCE_TREE = " << fixSeparators(dictionary[ "QT_SOURCE_TREE" ], true) << endl;
+ moduleStream << "QT_BUILD_TREE = " << formatPath(dictionary["QT_BUILD_TREE"]) << endl;
+ moduleStream << "QT_SOURCE_TREE = " << formatPath(dictionary["QT_SOURCE_TREE"]) << endl;
moduleStream << "QT_BUILD_PARTS = " << buildParts.join(" ") << endl << endl;
//so that we can build without an install first (which would be impossible)
QString hostSpec = dictionary[ "QMAKESPEC" ];
QString targetSpec = dictionary.contains("XQMAKESPEC") ? dictionary[ "XQMAKESPEC" ] : hostSpec;
- QString xmkspec_path = fixSeparators(sourcePath + "/mkspecs/" + targetSpec);
+ QString xmkspec_path = sourcePath + "/mkspecs/" + targetSpec;
if (QFile::exists(xmkspec_path))
- moduleStream << "XQMAKESPEC = " << escapeSeparators(xmkspec_path) << endl;
+ moduleStream << "XQMAKESPEC = " << xmkspec_path << endl;
else
- moduleStream << "XQMAKESPEC = " << fixSeparators(targetSpec, true) << endl;
- QString mkspec_path = fixSeparators(sourcePath + "/mkspecs/" + hostSpec);
+ moduleStream << "XQMAKESPEC = " << targetSpec << endl;
+ QString mkspec_path = sourcePath + "/mkspecs/" + hostSpec;
if (QFile::exists(mkspec_path))
- moduleStream << "QMAKESPEC = " << escapeSeparators(mkspec_path) << endl;
+ moduleStream << "QMAKESPEC = " << mkspec_path << endl;
else
- moduleStream << "QMAKESPEC = " << fixSeparators(hostSpec, true) << endl;
+ moduleStream << "QMAKESPEC = " << hostSpec << endl;
if (dictionary["QT_EDITION"] != "QT_EDITION_OPENSOURCE")
moduleStream << "DEFINES *= QT_EDITION=QT_EDITION_DESKTOP" << endl;
if (dictionary["CETEST"] == "yes") {
- moduleStream << "QT_CE_RAPI_INC = " << fixSeparators(dictionary[ "QT_CE_RAPI_INC" ], true) << endl;
- moduleStream << "QT_CE_RAPI_LIB = " << fixSeparators(dictionary[ "QT_CE_RAPI_LIB" ], true) << endl;
+ moduleStream << "QT_CE_RAPI_INC = " << formatPath(dictionary["QT_CE_RAPI_INC"]) << endl;
+ moduleStream << "QT_CE_RAPI_LIB = " << formatPath(dictionary["QT_CE_RAPI_LIB"]) << endl;
}
moduleStream << "#Qt for Windows CE c-runtime deployment" << endl
- << "QT_CE_C_RUNTIME = " << fixSeparators(dictionary[ "CE_CRT" ], true) << endl;
+ << "QT_CE_C_RUNTIME = " << formatPath(dictionary["CE_CRT"]) << endl;
if (dictionary["CE_SIGNATURE"] != QLatin1String("no"))
moduleStream << "DEFAULT_SIGNATURE=" << dictionary["CE_SIGNATURE"] << endl;
{
QString oldpwd = QDir::currentPath();
- QString newpwd = fixSeparators(QString("%1/config.tests/arch").arg(buildPath));
+ QString newpwd = QString("%1/config.tests/arch").arg(buildPath);
if (!QDir().exists(newpwd) && !QDir().mkpath(newpwd)) {
- cout << "Failed to create directory " << qPrintable(newpwd) << endl;
+ cout << "Failed to create directory " << qPrintable(QDir::toNativeSeparators(newpwd)) << endl;
dictionary["DONE"] = "error";
return;
}
if (!QDir::setCurrent(newpwd)) {
- cout << "Failed to change working directory to " << qPrintable(newpwd) << endl;
+ cout << "Failed to change working directory to " << qPrintable(QDir::toNativeSeparators(newpwd)) << endl;
dictionary["DONE"] = "error";
return;
}
QString subarchKey = data.subarchKey;
// run qmake
- QString command =
- fixSeparators(QString("%1/bin/qmake.exe -spec %2 %3/config.tests/arch/arch.pro 2>&1")
- .arg(buildPath, qmakespec, sourcePath));
+ QString command = QString("%1 -spec %2 %3 2>&1")
+ .arg(QDir::toNativeSeparators(buildPath + "/bin/qmake.exe"),
+ QDir::toNativeSeparators(qmakespec),
+ QDir::toNativeSeparators(sourcePath + "/config.tests/arch/arch.pro"));
Environment::execute(command);
// compile
{
QString oldpwd = QDir::currentPath();
- QString newpwd = fixSeparators(QString("%1/config.tests/%2").arg(buildPath, projectPath));
+ QString newpwd = QString("%1/config.tests/%2").arg(buildPath, projectPath);
if (!QDir().exists(newpwd) && !QDir().mkpath(newpwd)) {
- cout << "Failed to create directory " << qPrintable(newpwd) << endl;
+ cout << "Failed to create directory " << qPrintable(QDir::toNativeSeparators(newpwd)) << endl;
dictionary["DONE"] = "error";
return false;
}
if (!QDir::setCurrent(newpwd)) {
- cout << "Failed to change working directory to " << qPrintable(newpwd) << endl;
+ cout << "Failed to change working directory to " << qPrintable(QDir::toNativeSeparators(newpwd)) << endl;
dictionary["DONE"] = "error";
return false;
}
// run qmake
- QString command =
- fixSeparators(QString("%1/bin/qmake.exe %2/config.tests/%3 %4 2>&1")
- .arg(buildPath, sourcePath, projectPath, extraOptions));
+ QString command = QString("%1 %2 %3 2>&1")
+ .arg(QDir::toNativeSeparators(buildPath + "/bin/qmake.exe"),
+ QDir::toNativeSeparators(sourcePath + "/config.tests/" + projectPath),
+ extraOptions);
int code = 0;
QString output = Environment::execute(command, &code);
//cout << output << endl;
}
if (!dictionary["QMAKE_RPATHDIR"].isEmpty())
- configStream << "QMAKE_RPATHDIR += " << dictionary["QMAKE_RPATHDIR"] << endl;
+ configStream << "QMAKE_RPATHDIR += " << formatPath(dictionary["QMAKE_RPATHDIR"]) << endl;
if (!dictionary["QT_LIBINFIX"].isEmpty())
configStream << "QT_LIBINFIX = " << dictionary["QT_LIBINFIX"] << endl;
const QString angleDir = dictionary.value(QStringLiteral("ANGLE_DIR"));
if (!angleDir.isEmpty()) {
configStream
- << "QMAKE_INCDIR_OPENGL_ES2 = "
- << fixSeparators(angleDir + QStringLiteral("/include"), true) << '\n'
- << "QMAKE_LIBDIR_OPENGL_ES2_DEBUG = "
- << fixSeparators(angleDir + QStringLiteral("/lib/Debug"), true) << '\n'
- << "QMAKE_LIBDIR_OPENGL_ES2_RELEASE = "
- << fixSeparators(angleDir + QStringLiteral("/lib/Release"), true) + '\n';
+ << "QMAKE_INCDIR_OPENGL_ES2 = " << angleDir << "/include\n"
+ << "QMAKE_LIBDIR_OPENGL_ES2_DEBUG = " << angleDir << "/lib/Debug\n"
+ << "QMAKE_LIBDIR_OPENGL_ES2_RELEASE = " << angleDir << "/lib/Release\n";
}
}
<< "static const char qt_configure_installation [11 + 12] = \"qt_instdate=" << QDate::currentDate().toString(Qt::ISODate) << "\";" << endl
<< endl
<< "static const char qt_configure_prefix_path_strs[][12 + 512] = {" << endl
- << " \"qt_prfxpath=" << escapeSeparators(dictionary["QT_INSTALL_PREFIX"]) << "\"," << endl
- << " \"qt_docspath=" << escapeSeparators(dictionary["QT_INSTALL_DOCS"]) << "\"," << endl
- << " \"qt_hdrspath=" << escapeSeparators(dictionary["QT_INSTALL_HEADERS"]) << "\"," << endl
- << " \"qt_libspath=" << escapeSeparators(dictionary["QT_INSTALL_LIBS"]) << "\"," << endl
- << " \"qt_binspath=" << escapeSeparators(dictionary["QT_INSTALL_BINS"]) << "\"," << endl
- << " \"qt_plugpath=" << escapeSeparators(dictionary["QT_INSTALL_PLUGINS"]) << "\"," << endl
- << " \"qt_impspath=" << escapeSeparators(dictionary["QT_INSTALL_IMPORTS"]) << "\"," << endl
- << " \"qt_datapath=" << escapeSeparators(dictionary["QT_INSTALL_DATA"]) << "\"," << endl
- << " \"qt_trnspath=" << escapeSeparators(dictionary["QT_INSTALL_TRANSLATIONS"]) << "\"," << endl
- << " \"qt_xmplpath=" << escapeSeparators(dictionary["QT_INSTALL_EXAMPLES"]) << "\"," << endl
- << " \"qt_tstspath=" << escapeSeparators(dictionary["QT_INSTALL_TESTS"]) << "\"," << endl
+ << " \"qt_prfxpath=" << formatPath(dictionary["QT_INSTALL_PREFIX"]) << "\"," << endl
+ << " \"qt_docspath=" << formatPath(dictionary["QT_INSTALL_DOCS"]) << "\"," << endl
+ << " \"qt_hdrspath=" << formatPath(dictionary["QT_INSTALL_HEADERS"]) << "\"," << endl
+ << " \"qt_libspath=" << formatPath(dictionary["QT_INSTALL_LIBS"]) << "\"," << endl
+ << " \"qt_binspath=" << formatPath(dictionary["QT_INSTALL_BINS"]) << "\"," << endl
+ << " \"qt_plugpath=" << formatPath(dictionary["QT_INSTALL_PLUGINS"]) << "\"," << endl
+ << " \"qt_impspath=" << formatPath(dictionary["QT_INSTALL_IMPORTS"]) << "\"," << endl
+ << " \"qt_datapath=" << formatPath(dictionary["QT_INSTALL_DATA"]) << "\"," << endl
+ << " \"qt_trnspath=" << formatPath(dictionary["QT_INSTALL_TRANSLATIONS"]) << "\"," << endl
+ << " \"qt_xmplpath=" << formatPath(dictionary["QT_INSTALL_EXAMPLES"]) << "\"," << endl
+ << " \"qt_tstspath=" << formatPath(dictionary["QT_INSTALL_TESTS"]) << "\"," << endl
<< "#ifdef QT_BUILD_QMAKE" << endl
- << " \"qt_ssrtpath=" << escapeSeparators(dictionary["CFG_SYSROOT"]) << "\"," << endl
- << " \"qt_hpfxpath=" << escapeSeparators(dictionary["QT_HOST_PREFIX"]) << "\"," << endl
- << " \"qt_hbinpath=" << escapeSeparators(dictionary["QT_HOST_BINS"]) << "\"," << endl
- << " \"qt_hdatpath=" << escapeSeparators(dictionary["QT_HOST_DATA"]) << "\"," << endl
+ << " \"qt_ssrtpath=" << formatPath(dictionary["CFG_SYSROOT"]) << "\"," << endl
+ << " \"qt_hpfxpath=" << formatPath(dictionary["QT_HOST_PREFIX"]) << "\"," << endl
+ << " \"qt_hbinpath=" << formatPath(dictionary["QT_HOST_BINS"]) << "\"," << endl
+ << " \"qt_hdatpath=" << formatPath(dictionary["QT_HOST_DATA"]) << "\"," << endl
<< "#endif" << endl
<< "};" << endl
- //<< "static const char qt_configure_settings_path_str [256] = \"qt_stngpath=" << escapeSeparators(dictionary["QT_INSTALL_SETTINGS"]) << "\";" << endl
+ //<< "static const char qt_configure_settings_path_str [256] = \"qt_stngpath=" << formatPath(dictionary["QT_INSTALL_SETTINGS"]) << "\";" << endl
<< endl
<< "/* strlen( \"qt_lcnsxxxx\") == 12 */" << endl
<< "#define QT_CONFIGURE_LICENSEE qt_configure_licensee_str + 12;" << endl
sout << " SQLite2................." << dictionary[ "SQL_SQLITE2" ] << endl;
sout << " InterBase..............." << dictionary[ "SQL_IBASE" ] << endl << endl;
- sout << "Sources are in.............." << dictionary[ "QT_SOURCE_TREE" ] << endl;
- sout << "Build is done in............" << dictionary[ "QT_BUILD_TREE" ] << endl;
- sout << "Install prefix.............." << dictionary[ "QT_INSTALL_PREFIX" ] << endl;
- sout << "Headers installed to........" << dictionary[ "QT_INSTALL_HEADERS" ] << endl;
- sout << "Libraries installed to......" << dictionary[ "QT_INSTALL_LIBS" ] << endl;
- sout << "Plugins installed to........" << dictionary[ "QT_INSTALL_PLUGINS" ] << endl;
- sout << "Imports installed to........" << dictionary[ "QT_INSTALL_IMPORTS" ] << endl;
- sout << "Binaries installed to......." << dictionary[ "QT_INSTALL_BINS" ] << endl;
- sout << "Docs installed to..........." << dictionary[ "QT_INSTALL_DOCS" ] << endl;
- sout << "Data installed to..........." << dictionary[ "QT_INSTALL_DATA" ] << endl;
- sout << "Translations installed to..." << dictionary[ "QT_INSTALL_TRANSLATIONS" ] << endl;
- sout << "Examples installed to......." << dictionary[ "QT_INSTALL_EXAMPLES" ] << endl;
- sout << "Tests installed to.........." << dictionary[ "QT_INSTALL_TESTS" ] << endl;
+ sout << "Sources are in.............." << QDir::toNativeSeparators(dictionary["QT_SOURCE_TREE"]) << endl;
+ sout << "Build is done in............" << QDir::toNativeSeparators(dictionary["QT_BUILD_TREE"]) << endl;
+ sout << "Install prefix.............." << QDir::toNativeSeparators(dictionary["QT_INSTALL_PREFIX"]) << endl;
+ sout << "Headers installed to........" << QDir::toNativeSeparators(dictionary["QT_INSTALL_HEADERS"]) << endl;
+ sout << "Libraries installed to......" << QDir::toNativeSeparators(dictionary["QT_INSTALL_LIBS"]) << endl;
+ sout << "Plugins installed to........" << QDir::toNativeSeparators(dictionary["QT_INSTALL_PLUGINS"]) << endl;
+ sout << "Imports installed to........" << QDir::toNativeSeparators(dictionary["QT_INSTALL_IMPORTS"]) << endl;
+ sout << "Binaries installed to......." << QDir::toNativeSeparators(dictionary["QT_INSTALL_BINS"]) << endl;
+ sout << "Docs installed to..........." << QDir::toNativeSeparators(dictionary["QT_INSTALL_DOCS"]) << endl;
+ sout << "Data installed to..........." << QDir::toNativeSeparators(dictionary["QT_INSTALL_DATA"]) << endl;
+ sout << "Translations installed to..." << QDir::toNativeSeparators(dictionary["QT_INSTALL_TRANSLATIONS"]) << endl;
+ sout << "Examples installed to......." << QDir::toNativeSeparators(dictionary["QT_INSTALL_EXAMPLES"]) << endl;
+ sout << "Tests installed to.........." << QDir::toNativeSeparators(dictionary["QT_INSTALL_TESTS"]) << endl;
if (dictionary.contains("XQMAKESPEC") && dictionary["XQMAKESPEC"].startsWith(QLatin1String("wince"))) {
sout << "Using c runtime detection..." << dictionary[ "CE_CRT" ] << endl;
|| dictionary["VCPROJFILES"] == "yes");
while (generate) {
QString pwd = QDir::currentPath();
- QString dirPath = fixSeparators(buildPath + dirName);
+ QString dirPath = buildPath + dirName;
QStringList args;
- args << fixSeparators(buildPath + "/bin/qmake");
+ args << buildPath + "/bin/qmake";
if (doDsp) {
if (dictionary[ "DEPENDENCIES" ] == "no")
if (!dictionary[ "QMAKEADDITIONALARGS" ].isEmpty())
args << dictionary[ "QMAKEADDITIONALARGS" ];
- QDir::setCurrent(fixSeparators(dirPath));
+ QDir::setCurrent(dirPath);
if (int exitCode = Environment::execute(args, QStringList(), QStringList())) {
cout << "Qmake failed, return code " << exitCode << endl << endl;
dictionary[ "DONE" ] = "error";
if (it->directory == "tools/configure")
continue; // don't overwrite our own Makefile
- QString dirPath = fixSeparators(it->directory + "/");
+ QString dirPath = it->directory + '/';
QString projectName = it->proFile;
QString makefileName = buildPath + "/" + dirPath + it->target;
QStringList args;
- args << fixSeparators(buildPath + "/bin/qmake");
+ args << QDir::toNativeSeparators(buildPath + "/bin/qmake.exe");
args << sourcePath + "/" + dirPath + projectName;
args << dictionary[ "QMAKE_ALL_ARGS" ];
- cout << "For " << qPrintable(dirPath + projectName) << endl;
+ cout << "For " << qPrintable(QDir::toNativeSeparators(dirPath + projectName)) << endl;
args << "-o";
args << it->target;
if (!dictionary[ "QMAKEADDITIONALARGS" ].isEmpty())
args << dictionary[ "QMAKEADDITIONALARGS" ];
- QDir::setCurrent(fixSeparators(dirPath));
+ QDir::setCurrent(dirPath);
QFile file(makefileName);
if (!file.open(QFile::WriteOnly | QFile::Text)) {
printf("failed on dirPath=%s, makefile=%s\n",
- qPrintable(dirPath), qPrintable(makefileName));
+ qPrintable(QDir::toNativeSeparators(dirPath)),
+ qPrintable(QDir::toNativeSeparators(makefileName)));
continue;
}
QTextStream txt(&file);
projects / profile / ivi / qtbase.git / commitdiff