| /**************************************************************************** | |
| ** | |
| ** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). | |
| ** All rights reserved. | |
| ** Contact: Nokia Corporation (qt-info@nokia.com) | |
| ** | |
| ** This file is part of the tools applications of the Qt Toolkit. | |
| ** | |
| ** $QT_BEGIN_LICENSE:LGPL$ | |
| ** GNU Lesser General Public License Usage | |
| ** This file may be used under the terms of the GNU Lesser General Public | |
| ** License version 2.1 as published by the Free Software Foundation and | |
| ** appearing in the file LICENSE.LGPL included in the packaging of this | |
| ** file. Please review the following information to ensure the GNU Lesser | |
| ** General Public License version 2.1 requirements will be met: | |
| ** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. | |
| ** | |
| ** In addition, as a special exception, Nokia gives you certain additional | |
| ** rights. These rights are described in the Nokia Qt LGPL Exception | |
| ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. | |
| ** | |
| ** GNU General Public License Usage | |
| ** Alternatively, this file may be used under the terms of the GNU General | |
| ** Public License version 3.0 as published by the Free Software Foundation | |
| ** and appearing in the file LICENSE.GPL included in the packaging of this | |
| ** file. Please review the following information to ensure the GNU General | |
| ** Public License version 3.0 requirements will be met: | |
| ** http://www.gnu.org/copyleft/gpl.html. | |
| ** | |
| ** Other Usage | |
| ** Alternatively, this file may be used in accordance with the terms and | |
| ** conditions contained in a signed written agreement between you and Nokia. | |
| ** | |
| ** | |
| ** | |
| ** | |
| ** | |
| ** $QT_END_LICENSE$ | |
| ** | |
| ****************************************************************************/ | |
| #include "environment.h" | |
| #include <process.h> | |
| #include <iostream> | |
| #include <qdebug.h> | |
| #include <QDir> | |
| #include <QStringList> | |
| #include <QMap> | |
| #include <QDir> | |
| #include <QFile> | |
| #include <QFileInfo> | |
| //#define CONFIGURE_DEBUG_EXECUTE | |
| //#define CONFIGURE_DEBUG_CP_DIR | |
| using namespace std; | |
| #ifdef Q_OS_WIN32 | |
| #include <qt_windows.h> | |
| #endif | |
| #include <symbian/epocroot_p.h> // from tools/shared | |
| #include <windows/registry_p.h> // from tools/shared | |
| QT_BEGIN_NAMESPACE | |
| struct CompilerInfo{ | |
| Compiler compiler; | |
| const char *compilerStr; | |
| const char *regKey; | |
| const char *executable; | |
| } compiler_info[] = { | |
| // The compilers here are sorted in a reversed-preferred order | |
| {CC_BORLAND, "Borland C++", 0, "bcc32.exe"}, | |
| {CC_MINGW, "MinGW (Minimalist GNU for Windows)", 0, "g++.exe"}, | |
| {CC_INTEL, "Intel(R) C++ Compiler for 32-bit applications", 0, "icl.exe"}, // xilink.exe, xilink5.exe, xilink6.exe, xilib.exe | |
| {CC_MSVC6, "Microsoft (R) 32-bit C/C++ Optimizing Compiler (6.x)", "Software\\Microsoft\\VisualStudio\\6.0\\Setup\\Microsoft Visual C++\\ProductDir", "cl.exe"}, // link.exe, lib.exe | |
| {CC_NET2002, "Microsoft (R) 32-bit C/C++ Optimizing Compiler.NET 2002 (7.0)", "Software\\Microsoft\\VisualStudio\\7.0\\Setup\\VC\\ProductDir", "cl.exe"}, // link.exe, lib.exe | |
| {CC_NET2003, "Microsoft (R) 32-bit C/C++ Optimizing Compiler.NET 2003 (7.1)", "Software\\Microsoft\\VisualStudio\\7.1\\Setup\\VC\\ProductDir", "cl.exe"}, // link.exe, lib.exe | |
| {CC_NET2005, "Microsoft (R) 32-bit C/C++ Optimizing Compiler.NET 2005 (8.0)", "Software\\Microsoft\\VisualStudio\\SxS\\VC7\\8.0", "cl.exe"}, // link.exe, lib.exe | |
| {CC_NET2008, "Microsoft (R) 32-bit C/C++ Optimizing Compiler.NET 2008 (9.0)", "Software\\Microsoft\\VisualStudio\\SxS\\VC7\\9.0", "cl.exe"}, // link.exe, lib.exe | |
| {CC_NET2010, "Microsoft (R) 32-bit C/C++ Optimizing Compiler.NET 2010 (10.0)", "Software\\Microsoft\\VisualStudio\\SxS\\VC7\\10.0", "cl.exe"}, // link.exe, lib.exe | |
| {CC_UNKNOWN, "Unknown", 0, 0}, | |
| }; | |
| // Initialize static variables | |
| Compiler Environment::detectedCompiler = CC_UNKNOWN; | |
| /*! | |
| Returns the pointer to the CompilerInfo for a \a compiler. | |
| */ | |
| CompilerInfo *Environment::compilerInfo(Compiler compiler) | |
| { | |
| int i = 0; | |
| while(compiler_info[i].compiler != compiler && compiler_info[i].compiler != CC_UNKNOWN) | |
| ++i; | |
| return &(compiler_info[i]); | |
| } | |
| /*! | |
| Returns the qmakespec for the compiler detected on the system. | |
| */ | |
| QString Environment::detectQMakeSpec() | |
| { | |
| QString spec; | |
| switch (detectCompiler()) { | |
| case CC_NET2010: | |
| spec = "win32-msvc2010"; | |
| break; | |
| case CC_NET2008: | |
| spec = "win32-msvc2008"; | |
| break; | |
| case CC_NET2005: | |
| spec = "win32-msvc2005"; | |
| break; | |
| case CC_NET2003: | |
| spec = "win32-msvc2003"; | |
| break; | |
| case CC_NET2002: | |
| spec = "win32-msvc2002"; | |
| break; | |
| case CC_MSVC4: | |
| case CC_MSVC5: | |
| case CC_MSVC6: | |
| spec = "win32-msvc"; | |
| break; | |
| case CC_INTEL: | |
| spec = "win32-icc"; | |
| break; | |
| case CC_MINGW: | |
| spec = "win32-g++"; | |
| break; | |
| case CC_BORLAND: | |
| spec = "win32-borland"; | |
| break; | |
| default: | |
| break; | |
| } | |
| return spec; | |
| } | |
| /*! | |
| Returns the enum of the compiler which was detected on the system. | |
| The compilers are detected in the order as entered into the | |
| compiler_info list. | |
| If more than one compiler is found, CC_UNKNOWN is returned. | |
| */ | |
| Compiler Environment::detectCompiler() | |
| { | |
| #ifndef Q_OS_WIN32 | |
| return MSVC6; // Always generate MSVC 6.0 versions on other platforms | |
| #else | |
| if(detectedCompiler != CC_UNKNOWN) | |
| return detectedCompiler; | |
| int installed = 0; | |
| // Check for compilers in registry first, to see which version is in PATH | |
| QString paths = qgetenv("PATH"); | |
| QStringList pathlist = paths.toLower().split(";"); | |
| for(int i = 0; compiler_info[i].compiler; ++i) { | |
| QString productPath = qt_readRegistryKey(HKEY_LOCAL_MACHINE, compiler_info[i].regKey).toLower(); | |
| if (productPath.length()) { | |
| QStringList::iterator it; | |
| for(it = pathlist.begin(); it != pathlist.end(); ++it) { | |
| if((*it).contains(productPath)) { | |
| ++installed; | |
| detectedCompiler = compiler_info[i].compiler; | |
| break; | |
| } | |
| } | |
| } | |
| } | |
| // Now just go looking for the executables, and accept any executable as the lowest version | |
| if (!installed) { | |
| for(int i = 0; compiler_info[i].compiler; ++i) { | |
| QString executable = QString(compiler_info[i].executable).toLower(); | |
| if (executable.length() && Environment::detectExecutable(executable)) { | |
| ++installed; | |
| detectedCompiler = compiler_info[i].compiler; | |
| break; | |
| } | |
| } | |
| } | |
| if (installed > 1) { | |
| cout << "Found more than one known compiler! Using \"" << compilerInfo(detectedCompiler)->compilerStr << "\"" << endl; | |
| detectedCompiler = CC_UNKNOWN; | |
| } | |
| return detectedCompiler; | |
| #endif | |
| }; | |
| /*! | |
| Returns true if the \a executable could be loaded, else false. | |
| This means that the executable either is in the current directory | |
| or in the PATH. | |
| */ | |
| bool Environment::detectExecutable(const QString &executable) | |
| { | |
| PROCESS_INFORMATION procInfo; | |
| memset(&procInfo, 0, sizeof(procInfo)); | |
| STARTUPINFO startInfo; | |
| memset(&startInfo, 0, sizeof(startInfo)); | |
| startInfo.cb = sizeof(startInfo); | |
| bool couldExecute = CreateProcess(0, (wchar_t*)executable.utf16(), | |
| 0, 0, false, | |
| CREATE_NO_WINDOW | CREATE_SUSPENDED, | |
| 0, 0, &startInfo, &procInfo); | |
| if (couldExecute) { | |
| CloseHandle(procInfo.hThread); | |
| TerminateProcess(procInfo.hProcess, 0); | |
| CloseHandle(procInfo.hProcess); | |
| } | |
| return couldExecute; | |
| } | |
| /*! | |
| Creates a commandling from \a program and it \a arguments, | |
| escaping characters that needs it. | |
| */ | |
| static QString qt_create_commandline(const QString &program, const QStringList &arguments) | |
| { | |
| QString programName = program; | |
| if (!programName.startsWith("\"") && !programName.endsWith("\"") && programName.contains(" ")) | |
| programName = "\"" + programName + "\""; | |
| programName.replace("/", "\\"); | |
| QString args; | |
| // add the prgram as the first arrg ... it works better | |
| args = programName + " "; | |
| for (int i=0; i<arguments.size(); ++i) { | |
| QString tmp = arguments.at(i); | |
| // in the case of \" already being in the string the \ must also be escaped | |
| tmp.replace( "\\\"", "\\\\\"" ); | |
| // escape a single " because the arguments will be parsed | |
| tmp.replace( "\"", "\\\"" ); | |
| if (tmp.isEmpty() || tmp.contains(' ') || tmp.contains('\t')) { | |
| // The argument must not end with a \ since this would be interpreted | |
| // as escaping the quote -- rather put the \ behind the quote: e.g. | |
| // rather use "foo"\ than "foo\" | |
| QString endQuote("\""); | |
| int i = tmp.length(); | |
| while (i>0 && tmp.at(i-1) == '\\') { | |
| --i; | |
| endQuote += "\\"; | |
| } | |
| args += QString(" \"") + tmp.left(i) + endQuote; | |
| } else { | |
| args += ' ' + tmp; | |
| } | |
| } | |
| return args; | |
| } | |
| /*! | |
| Creates a QByteArray of the \a environment. | |
| */ | |
| static QByteArray qt_create_environment(const QStringList &environment) | |
| { | |
| QByteArray envlist; | |
| if (environment.isEmpty()) | |
| return envlist; | |
| int pos = 0; | |
| // add PATH if necessary (for DLL loading) | |
| QByteArray path = qgetenv("PATH"); | |
| if (environment.filter(QRegExp("^PATH=",Qt::CaseInsensitive)).isEmpty() && !path.isNull()) { | |
| QString tmp = QString(QLatin1String("PATH=%1")).arg(QString::fromLocal8Bit(path)); | |
| uint tmpSize = sizeof(wchar_t) * (tmp.length() + 1); | |
| envlist.resize(envlist.size() + tmpSize); | |
| memcpy(envlist.data() + pos, tmp.utf16(), tmpSize); | |
| pos += tmpSize; | |
| } | |
| // add the user environment | |
| foreach (const QString &tmp, environment) { | |
| uint tmpSize = sizeof(wchar_t) * (tmp.length() + 1); | |
| envlist.resize(envlist.size() + tmpSize); | |
| memcpy(envlist.data() + pos, tmp.utf16(), tmpSize); | |
| pos += tmpSize; | |
| } | |
| // add the 2 terminating 0 (actually 4, just to be on the safe side) | |
| envlist.resize(envlist.size() + 4); | |
| envlist[pos++] = 0; | |
| envlist[pos++] = 0; | |
| envlist[pos++] = 0; | |
| envlist[pos++] = 0; | |
| return envlist; | |
| } | |
| /*! | |
| Executes the command described in \a arguments, in the | |
| environment inherited from the parent process, with the | |
| \a additionalEnv settings applied. | |
| \a removeEnv removes the specified environment variables from | |
| the environment of the executed process. | |
| Returns the exit value of the process, or -1 if the command could | |
| not be executed. | |
| This function uses _(w)spawnvpe to spawn a process by searching | |
| through the PATH environment variable. | |
| */ | |
| int Environment::execute(QStringList arguments, const QStringList &additionalEnv, const QStringList &removeEnv) | |
| { | |
| #ifdef CONFIGURE_DEBUG_EXECUTE | |
| qDebug() << "About to Execute: " << arguments; | |
| qDebug() << " " << QDir::currentPath(); | |
| qDebug() << " " << additionalEnv; | |
| qDebug() << " " << removeEnv; | |
| #endif | |
| // Create the full environment from the current environment and | |
| // the additionalEnv strings, then remove all variables defined | |
| // in removeEnv | |
| QMap<QString, QString> fullEnvMap; | |
| LPWSTR envStrings = GetEnvironmentStrings(); | |
| if (envStrings) { | |
| int strLen = 0; | |
| for (LPWSTR envString = envStrings; *(envString); envString += strLen + 1) { | |
| strLen = wcslen(envString); | |
| QString str = QString((const QChar*)envString, strLen); | |
| if (!str.startsWith("=")) { // These are added by the system | |
| int sepIndex = str.indexOf('='); | |
| fullEnvMap.insert(str.left(sepIndex).toUpper(), str.mid(sepIndex +1)); | |
| } | |
| } | |
| } | |
| FreeEnvironmentStrings(envStrings); | |
| // Add additionalEnv variables | |
| for (int i = 0; i < additionalEnv.count(); ++i) { | |
| const QString &str = additionalEnv.at(i); | |
| int sepIndex = str.indexOf('='); | |
| fullEnvMap.insert(str.left(sepIndex).toUpper(), str.mid(sepIndex +1)); | |
| } | |
| // Remove removeEnv variables | |
| for (int j = 0; j < removeEnv.count(); ++j) | |
| fullEnvMap.remove(removeEnv.at(j).toUpper()); | |
| // Add all variables to a QStringList | |
| QStringList fullEnv; | |
| QMapIterator<QString, QString> it(fullEnvMap); | |
| while (it.hasNext()) { | |
| it.next(); | |
| fullEnv += QString(it.key() + "=" + it.value()); | |
| } | |
| // ---------------------------- | |
| QString program = arguments.takeAt(0); | |
| QString args = qt_create_commandline(program, arguments); | |
| QByteArray envlist = qt_create_environment(fullEnv); | |
| DWORD exitCode = DWORD(-1); | |
| PROCESS_INFORMATION procInfo; | |
| memset(&procInfo, 0, sizeof(procInfo)); | |
| STARTUPINFO startInfo; | |
| memset(&startInfo, 0, sizeof(startInfo)); | |
| startInfo.cb = sizeof(startInfo); | |
| bool couldExecute = CreateProcess(0, (wchar_t*)args.utf16(), | |
| 0, 0, true, CREATE_UNICODE_ENVIRONMENT, | |
| envlist.isEmpty() ? 0 : envlist.data(), | |
| 0, &startInfo, &procInfo); | |
| if (couldExecute) { | |
| WaitForSingleObject(procInfo.hProcess, INFINITE); | |
| GetExitCodeProcess(procInfo.hProcess, &exitCode); | |
| CloseHandle(procInfo.hThread); | |
| CloseHandle(procInfo.hProcess); | |
| } | |
| if (exitCode == DWORD(-1)) { | |
| switch(GetLastError()) { | |
| case E2BIG: | |
| cerr << "execute: Argument list exceeds 1024 bytes" << endl; | |
| foreach (const QString &arg, arguments) | |
| cerr << " (" << arg.toLocal8Bit().constData() << ")" << endl; | |
| break; | |
| case ENOENT: | |
| cerr << "execute: File or path is not found (" << program.toLocal8Bit().constData() << ")" << endl; | |
| break; | |
| case ENOEXEC: | |
| cerr << "execute: Specified file is not executable or has invalid executable-file format (" << program.toLocal8Bit().constData() << ")" << endl; | |
| break; | |
| case ENOMEM: | |
| cerr << "execute: Not enough memory is available to execute new process." << endl; | |
| break; | |
| default: | |
| cerr << "execute: Unknown error" << endl; | |
| foreach (const QString &arg, arguments) | |
| cerr << " (" << arg.toLocal8Bit().constData() << ")" << endl; | |
| break; | |
| } | |
| } | |
| return exitCode; | |
| } | |
| /*! | |
| Copies the \a srcDir contents into \a destDir. | |
| If \a includeSrcDir is not empty, any files with 'h', 'prf', or 'conf' suffixes | |
| will not be copied over from \a srcDir. Instead a new file will be created | |
| in \a destDir with the same name and that file will include a file with the | |
| same name from the \a includeSrcDir using relative path and appropriate | |
| syntax for the file type. | |
| Returns true if copying was successful. | |
| */ | |
| bool Environment::cpdir(const QString &srcDir, | |
| const QString &destDir, | |
| const QString &includeSrcDir) | |
| { | |
| QString cleanSrcName = QDir::cleanPath(srcDir); | |
| QString cleanDstName = QDir::cleanPath(destDir); | |
| QString cleanIncludeName = QDir::cleanPath(includeSrcDir); | |
| #ifdef CONFIGURE_DEBUG_CP_DIR | |
| qDebug() << "Attempt to cpdir " << cleanSrcName << "->" << cleanDstName; | |
| #endif | |
| if(!QFile::exists(cleanDstName) && !QDir().mkpath(cleanDstName)) { | |
| qDebug() << "cpdir: Failure to create " << cleanDstName; | |
| return false; | |
| } | |
| bool result = true; | |
| QDir dir = QDir(cleanSrcName); | |
| QDir destinationDir = QDir(cleanDstName); | |
| QFileInfoList allEntries = dir.entryInfoList(QDir::AllDirs | QDir::Files | QDir::NoDotAndDotDot); | |
| for (int i = 0; result && (i < allEntries.count()); ++i) { | |
| QFileInfo entry = allEntries.at(i); | |
| bool intermediate = true; | |
| if (entry.isDir()) { | |
| QString newIncSrcDir; | |
| if (!includeSrcDir.isEmpty()) | |
| newIncSrcDir = QString("%1/%2").arg(cleanIncludeName).arg(entry.fileName()); | |
| intermediate = cpdir(QString("%1/%2").arg(cleanSrcName).arg(entry.fileName()), | |
| QString("%1/%2").arg(cleanDstName).arg(entry.fileName()), | |
| newIncSrcDir); | |
| } else { | |
| QString destFile = QString("%1/%2").arg(cleanDstName).arg(entry.fileName()); | |
| #ifdef CONFIGURE_DEBUG_CP_DIR | |
| qDebug() << "About to cp (file)" << entry.absoluteFilePath() << "->" << destFile; | |
| #endif | |
| QFile::remove(destFile); | |
| QString suffix = entry.suffix(); | |
| if (!includeSrcDir.isEmpty() && (suffix == "prf" || suffix == "conf" || suffix == "h")) { | |
| QString relativeIncludeFilePath = QString("%1/%2").arg(cleanIncludeName).arg(entry.fileName()); | |
| relativeIncludeFilePath = destinationDir.relativeFilePath(relativeIncludeFilePath); | |
| #ifdef CONFIGURE_DEBUG_CP_DIR | |
| qDebug() << "...instead generate relative include to" << relativeIncludeFilePath; | |
| #endif | |
| QFile currentFile(destFile); | |
| if (currentFile.open(QFile::WriteOnly | QFile::Text)) { | |
| QTextStream fileStream; | |
| fileStream.setDevice(¤tFile); | |
| if (suffix == "prf" || suffix == "conf") { | |
| if (entry.fileName() == "qmake.conf") { | |
| // While QMAKESPEC_ORIGINAL being relative or absolute doesn't matter for the | |
| // primary use of this variable by qmake to identify the original mkspec, the | |
| // variable is also used for few special cases where the absolute path is required. | |
| // Conversely, the include of the original qmake.conf must be done using relative path, | |
| // as some Qt binary deployments are done in a manner that doesn't allow for patching | |
| // the paths at the installation time. | |
| fileStream << "QMAKESPEC_ORIGINAL=" << cleanSrcName << endl << endl; | |
| } | |
| fileStream << "include(" << relativeIncludeFilePath << ")" << endl << endl; | |
| } else if (suffix == "h") { | |
| fileStream << "#include \"" << relativeIncludeFilePath << "\"" << endl << endl; | |
| } | |
| fileStream.flush(); | |
| currentFile.close(); | |
| } | |
| } else { | |
| intermediate = QFile::copy(entry.absoluteFilePath(), destFile); | |
| SetFileAttributes((wchar_t*)destFile.utf16(), FILE_ATTRIBUTE_NORMAL); | |
| } | |
| } | |
| if(!intermediate) { | |
| qDebug() << "cpdir: Failure for " << entry.fileName() << entry.isDir(); | |
| result = false; | |
| } | |
| } | |
| return result; | |
| } | |
| bool Environment::rmdir(const QString &name) | |
| { | |
| bool result = true; | |
| QString cleanName = QDir::cleanPath(name); | |
| QDir dir = QDir(cleanName); | |
| QFileInfoList allEntries = dir.entryInfoList(QDir::AllDirs | QDir::Files | QDir::NoDotAndDotDot); | |
| for (int i = 0; result && (i < allEntries.count()); ++i) { | |
| QFileInfo entry = allEntries.at(i); | |
| if (entry.isDir()) { | |
| result &= rmdir(entry.absoluteFilePath()); | |
| } else { | |
| result &= QFile::remove(entry.absoluteFilePath()); | |
| } | |
| } | |
| result &= dir.rmdir(cleanName); | |
| return result; | |
| } | |
| QString Environment::symbianEpocRoot() | |
| { | |
| // Call function defined in tools/shared/symbian/epocroot_p.h | |
| return ::qt_epocRoot(); | |
| } | |
| QT_END_NAMESPACE |