FCL/sf/mw/qt: comparison qmake/generators/symbian/symmake.cpp

equal deleted inserted replaced

-:41300fa6a67c
+:f7bc934e204c
 /****************************************************************************
 **
-** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the qmake application of the Qt Toolkit.
 **
 ** $QT_END_LICENSE$
 **
 ****************************************************************************/
 #include "symmake.h"
-#include "initprojectdeploy_symbian.h"
 #include <qstring.h>
 #include <qhash.h>
 #include <qstringlist.h>
 #include <qdir.h>
 #include <qdatetime.h>
 #include <stdlib.h>
 #include <qdebug.h>
 #include <qxmlstream.h>
-#include <qsettings>
+#include <QSettings>
+// Included from tools/shared
+#include <symbian/epocroot.h>
 #define RESOURCE_DIRECTORY_MMP "/resource/apps"
 #define RESOURCE_DIRECTORY_RESOURCE "\\\\resource\\\\apps\\\\"
 #define REGISTRATION_RESOURCE_DIRECTORY_HW "/private/10003a3f/import/apps"
 #define PLUGIN_COMMON_DEF_FILE_FOR_MMP "./plugin_common.def"
 #define PLUGIN_COMMON_DEF_FILE_ACTUAL "plugin_commonU.def"
-#define BLD_INF_FILENAME_LEN (sizeof(BLD_INF_FILENAME) - 1)
 #define BLD_INF_RULES_BASE "BLD_INF_RULES."
 #define BLD_INF_TAG_PLATFORMS "prj_platforms"
 #define BLD_INF_TAG_MMPFILES "prj_mmpfiles"
 #define BLD_INF_TAG_TESTMMPFILES "prj_testmmpfiles"
 #define BLD_INF_TAG_EXTENSIONS "prj_extensions"
+#define BLD_INF_TAG_TESTEXTENSIONS "prj_testextensions"
 #define RSS_RULES "RSS_RULES"
 #define RSS_RULES_BASE "RSS_RULES."
 #define RSS_TAG_NBROFICONS "number_of_icons"
 #define RSS_TAG_ICONFILE "icon_file"
+#define RSS_TAG_HEADER "header"
+#define RSS_TAG_SERVICE_LIST "service_list"
+#define RSS_TAG_FILE_OWNERSHIP_LIST "file_ownership_list"
+#define RSS_TAG_DATATYPE_LIST "datatype_list"
+#define RSS_TAG_FOOTER "footer"
+#define RSS_TAG_DEFAULT "default_rules" // Same as just giving rules without tag
 #define MMP_TARGET "TARGET"
 #define MMP_TARGETTYPE "TARGETTYPE"
 #define MMP_SECUREID "SECUREID"
 #define MMP_OPTION_CW "OPTION CW"
 #define MMP_VERSION "VERSION"
 #define MMP_START_RESOURCE "START RESOURCE"
 #define MMP_END_RESOURCE "END"
 #define SIS_TARGET "sis"
+#define INSTALLER_SIS_TARGET "installer_sis"
+#define ROM_STUB_SIS_TARGET "stub_sis"
 #define OK_SIS_TARGET "ok_sis"
+#define OK_INSTALLER_SIS_TARGET "ok_installer_sis"
+#define OK_ROM_STUB_SIS_TARGET "ok_stub_sis"
 #define FAIL_SIS_NOPKG_TARGET "fail_sis_nopkg"
 #define FAIL_SIS_NOCACHE_TARGET "fail_sis_nocache"
-#define RESTORE_BUILD_TARGET "restore_build"
 #define PRINT_FILE_CREATE_ERROR(filename) fprintf(stderr, "Error: Could not create '%s'\n", qPrintable(filename));
+#define MANUFACTURER_NOTE_FILE "manufacturer_note.txt"
+#define DEFAULT_MANUFACTURER_NOTE \
+"The package is not supported for devices from this manufacturer. Please try the selfsigned " \
+"version of the package instead."
 QString SymbianMakefileGenerator::fixPathForMmp(const QString& origPath, const QDir& parentDir)
 {
 static QString epocRootStr;
 if (epocRootStr.isEmpty()) {
-QFileInfo efi(epocRoot());
+epocRootStr = epocRoot();
-epocRootStr = efi.canonicalFilePath();
+QFileInfo efi(epocRootStr);
-if (epocRootStr.isEmpty()) {
+if (!efi.exists() || epocRootStr.isEmpty()) {
 fprintf(stderr, "Unable to resolve epocRoot '%s' to real dir on current drive, defaulting to '/' for mmp paths\n", qPrintable(epocRoot()));
 epocRootStr = "/";
+} else {
+epocRootStr = efi.absoluteFilePath();
 }
 if (!epocRootStr.endsWith("/"))
 epocRootStr += "/";
 epocRootStr += "epoc32/";
 resultPath = ".";
 return resultPath;
 }
-QString SymbianMakefileGenerator::canonizePath(const QString& origPath)
+QString SymbianMakefileGenerator::absolutizePath(const QString& origPath)
 {
-// Since current path gets appended almost always anyway, use it as default
-// for nonexisting paths.
-static QString defaultPath;
-if (defaultPath.isEmpty()) {
-QFileInfo fi(".");
-defaultPath = fi.canonicalFilePath();
-}
 // Prepend epocroot to any paths beginning with "/epoc32/"
 QString resultPath = QDir::fromNativeSeparators(origPath);
-QString tempPath(resultPath);
+if (resultPath.startsWith("/epoc32/", Qt::CaseInsensitive))
-bool isEpoc = false;
-if (resultPath.startsWith("/epoc32/", Qt::CaseInsensitive)) {
-isEpoc = true;
 resultPath = QDir::fromNativeSeparators(epocRoot()) + resultPath.mid(1);
-}
 QFileInfo fi(fileInfo(resultPath));
-if(fi.isDir()) {
-if (isEpoc)
+// Since origPath can be something given in HEADERS, we need to check if we are dealing
-resultPath = fi.absoluteFilePath();//canonicalFilePath();
+// with a file or a directory. In case the origPath doesn't yet exist, isFile() returns
-else
+// false and we default to assuming it is a dir.
-resultPath = fi.canonicalFilePath();
+if (fi.isFile()) {
+resultPath = fi.absolutePath();
 } else {
-if (isEpoc)
+resultPath = fi.absoluteFilePath();
-resultPath = fi.absolutePath();//canonicalPath();
-else
-resultPath = fi.canonicalPath();
-}
-//some fix for the not existed EPOC32\include folder
-if (isEpoc) {
-int index = resultPath.lastIndexOf("/epoc32/");
-QString tmpRes = resultPath.mid(index);
-if (tmpRes != tempPath) {
-//we have the problems for not existed include directory
-//change the path
-resultPath.replace(tmpRes, tempPath);
-}
 }
 resultPath = QDir::cleanPath(resultPath);
-if (resultPath.isEmpty())
-resultPath = defaultPath;
 return resultPath;
 }
 SymbianMakefileGenerator::SymbianMakefileGenerator() : MakefileGenerator() { }
 {
 writeHeader(t);
 QString numberOfIcons;
 QString iconFile;
-QStringList userRssRules;
+QMap<QString, QStringList> userRssRules;
 readRssRules(numberOfIcons, iconFile, userRssRules);
 // Get the application translations and convert to symbian OS lang code, i.e. decical number
 QStringList symbianLangCodes = symbianLangCodesFromTsFiles();
 // Generate pkg files if there are any actual files to deploy
 bool generatePkg = false;
+DeploymentList depList;
 if (targetType == TypeExe) {
 generatePkg = true;
 } else {
 foreach(QString item, project->values("DEPLOYMENT")) {
 if (!project->values(item + ".sources").isEmpty()) {
 }
 }
 }
 if (generatePkg) {
-generatePkgFile(iconFile);
+generatePkgFile(iconFile, depList);
 }
-writeBldInfContent(t, generatePkg, iconFile);
+writeBldInfContent(t, generatePkg, iconFile, depList);
 // Generate empty wrapper makefile here, because wrapper makefile must exist before writeMkFile,
 // but all required data is not yet available.
 bool isPrimaryMakefile = true;
 QString wrapperFileName("Makefile");
 QString outputFileName = fileInfo(Option::output.fileName()).fileName();
 if (outputFileName != BLD_INF_FILENAME) {
-wrapperFileName.append(".").append((outputFileName.size() > BLD_INF_FILENAME_LEN && outputFileName.left(BLD_INF_FILENAME_LEN) == BLD_INF_FILENAME) ? outputFileName.mid(8) : outputFileName);
+wrapperFileName.append(".").append(outputFileName.startsWith(BLD_INF_FILENAME)
+? outputFileName.mid(sizeof(BLD_INF_FILENAME))
+: outputFileName);
 isPrimaryMakefile = false;
 }
 QFile wrapperMakefile(wrapperFileName);
 if (wrapperMakefile.open(QIODevice::WriteOnly)) {
 mmpFilename.append(uid3);
 mmpFilename.append(Option::mmp_ext);
 writeMmpFile(mmpFilename, symbianLangCodes);
 if (targetType == TypeExe) {
-if (!project->values("CONFIG").contains("no_icon", Qt::CaseInsensitive)) {
+if (!project->isActiveConfig("no_icon")) {
 writeRegRssFile(userRssRules);
 writeRssFile(numberOfIcons, iconFile);
 writeLocFile(symbianLangCodes);
 if (!project->values("SYMBIANTRANSLATIONS").isEmpty())
 writeSymbianLocFile(symbianLangCodes);
 writeWrapperMakefile(wrapperMakefile, isPrimaryMakefile);
 return true;
 }
-void SymbianMakefileGenerator::generatePkgFile(const QString &iconFile)
+void SymbianMakefileGenerator::generatePkgFile(const QString &iconFile, DeploymentList &depList)
 {
 QString pkgFilename = QString("%1_template.%2")
 .arg(fixedTarget)
 .arg("pkg");
 QFile pkgFile(pkgFilename);
 }
 if (Option::mkfile::listgen) {
 generatePrint(fileInfo(pkgFile.fileName()).absoluteFilePath());
 }
 generatedFiles << pkgFile.fileName();
+QTextStream t(&pkgFile);
+QString installerSisHeader = project->values("DEPLOYMENT.installer_header").join("\n");
+if (installerSisHeader.isEmpty())
+installerSisHeader = "0xA000D7CE"; // Use default self-signable UID if not defined
+QString wrapperStreamBuffer;
+QTextStream tw(&wrapperStreamBuffer);
+QString dateStr = QDateTime::currentDateTime().toString(Qt::ISODate);
 // Header info
-QTextStream t(&pkgFile);
+QString wrapperPkgFilename = QString("%1_installer.%2")
-t << QString("; %1 generated by qmake at %2").arg(pkgFilename).arg(QDateTime::currentDateTime().toString(Qt::ISODate))  << endl;
+.arg(fixedTarget)
-t << "; This file is generated by qmake and should not be modified by the user" << endl;
+.arg("pkg");
-t << ";" << endl << endl;
+QString headerComment = "; %1 generated by qmake at %2\n"
+"; This file is generated by qmake and should not be modified by the user\n"
+";\n\n";
+t << headerComment.arg(pkgFilename).arg(dateStr);
+tw << headerComment.arg(wrapperPkgFilename).arg(dateStr);
 // Construct QStringList from pkg_prerules since we need search it before printed to file
+// Note: Though there can't be more than one language or header line, use stringlists
+// in case user wants comments to go with the rules.
 QStringList rawPkgPreRules;
+QStringList languageRules;
+QStringList headerRules;
 foreach(QString deploymentItem, project->values("DEPLOYMENT")) {
 foreach(QString pkgrulesItem, project->values(deploymentItem + ".pkg_prerules")) {
 QStringList pkgrulesValue = project->values(pkgrulesItem);
 // If there is no stringlist defined for a rule, use rule name directly
 // This is convenience for defining single line mmp statements
 if (pkgrulesValue.isEmpty()) {
-rawPkgPreRules << pkgrulesItem;
+if (pkgrulesItem.startsWith("&"))
+languageRules << pkgrulesItem;
+else if (pkgrulesItem.startsWith("#"))
+headerRules << pkgrulesItem;
+else
+rawPkgPreRules << pkgrulesItem;
 } else {
-foreach(QString pkgrule, pkgrulesValue) {
+if (containsStartWithItem('&', pkgrulesValue)) {
-rawPkgPreRules << pkgrule;
+foreach(QString pkgrule, pkgrulesValue) {
+languageRules << pkgrule;
+}
+} else if (containsStartWithItem('#', pkgrulesValue)) {
+foreach(QString pkgrule, pkgrulesValue) {
+headerRules << pkgrule;
+}
+} else {
+foreach(QString pkgrule, pkgrulesValue) {
+rawPkgPreRules << pkgrule;
+}
 }
 }
 }
 }
 // Apply some defaults if specific data does not exist in PKG pre-rules
-if (!containsStartWithItem('&', rawPkgPreRules)) {
+if (languageRules.isEmpty()) {
 // language, (*** hardcoded to english atm, should be parsed from TRANSLATIONS)
-t << "; Language" << endl;
+languageRules << "; Language\n&EN\n\n";
-t << "&EN" << endl << endl;
+} else if (headerRules.isEmpty()) {
-} else {
 // In case user defines langs, he must take care also about SIS header
-if (!containsStartWithItem('#', rawPkgPreRules))
+fprintf(stderr, "Warning: If language is defined with DEPLOYMENT pkg_prerules, also the SIS header must be defined\n");
-fprintf(stderr, "Warning: If language is defined with DEPLOYMENT pkg_prerules, also the SIS header must be defined\n");
+}
-}
+t << languageRules.join("\n") << endl;
+tw << languageRules.join("\n") << endl;
 // name of application, UID and version
 QString applicationVersion = project->first("VERSION").isEmpty() ? "1,0,0" : project->first("VERSION").replace('.', ',');
+QString sisHeader = "; SIS header: name, uid, version\n#{\"%1\"},(%2),%3\n\n";
-if (!containsStartWithItem('#', rawPkgPreRules)) {
+QString visualTarget = escapeFilePath(fileFixify(project->first("TARGET")));
-QString visualTarget = escapeFilePath(fileFixify(project->first("TARGET")));
+visualTarget = removePathSeparators(visualTarget);
-visualTarget = removePathSeparators(visualTarget);
+QString wrapperTarget = visualTarget + " installer";
-t << "; SIS header: name, uid, version" << endl;
+if (installerSisHeader.startsWith("0x", Qt::CaseInsensitive)) {
-t << QString("#{\"%1\"},(%2),%3").arg(visualTarget).arg(uid3).arg(applicationVersion) << endl << endl;
+tw << sisHeader.arg(wrapperTarget).arg(installerSisHeader).arg(applicationVersion);
-}
+} else {
+tw << installerSisHeader << endl;
+}
+if (headerRules.isEmpty())
+t << sisHeader.arg(visualTarget).arg(uid3).arg(applicationVersion);
+else
+t << headerRules.join("\n") << endl;
 // Localized vendor name
+QString vendorName;
 if (!containsStartWithItem('%', rawPkgPreRules)) {
-t << "; Localised Vendor name" << endl;
+vendorName += "; Localised Vendor name\n%{\"Vendor\"}\n\n";
-t << "%{\"Vendor\"}" << endl << endl;
 }
 // Unique vendor name
 if (!containsStartWithItem(':', rawPkgPreRules)) {
-t << "; Unique Vendor name" << endl;
+vendorName += "; Unique Vendor name\n:\"Vendor\"\n\n";
-t << ":\"Vendor\"" << endl << endl;
+}
-}
+t << vendorName;
+tw << vendorName;
 // PKG pre-rules - these are added before actual file installations i.e. SIS package body
 if (rawPkgPreRules.size()) {
-t << "; Manual PKG pre-rules from PRO files" << endl;
+QString comment = "\n; Manual PKG pre-rules from PRO files\n";
+t << comment;
+tw << comment;
 foreach(QString item, rawPkgPreRules) {
+// Only regular pkg file should have package dependencies or pkg header if that is
+// defined using prerules.
+if (!item.startsWith("(") && !item.startsWith("#")) {
+tw << item << endl;
+}
 t << item << endl;
 }
 t << endl;
+tw << endl;
+}
+// Begin Manufacturer block
+if (!project->values("DEPLOYMENT.manufacturers").isEmpty()) {
+QString manufacturerStr("IF ");
+foreach(QString manufacturer, project->values("DEPLOYMENT.manufacturers")) {
+manufacturerStr.append(QString("(MANUFACTURER)=(%1) OR \n   ").arg(manufacturer));
+}
+// Remove the final OR
+manufacturerStr.chop(8);
+t << manufacturerStr << endl;
 }
 // Install paths on the phone *** should be dynamic at some point
 QString installPathBin = "!:\\sys\\bin";
 QString installPathResource = "!:\\resource\\apps";
 QString installPathRegResource = "!:\\private\\10003a3f\\import\\apps";
 // Find location of builds
 QString epocReleasePath = QString("%1epoc32/release/$(PLATFORM)/$(TARGET)")
 .arg(epocRoot());
 if (targetType == TypeExe) {
 // deploy .exe file
 t << "; Executable and default resource files" << endl;
 QString exeFile = fixedTarget + ".exe";
 .arg(exeFile)
 .arg(installPathBin)
 .arg(exeFile) << endl;
 // deploy rsc & reg_rsc file
-if (!project->values("CONFIG").contains("no_icon", Qt::CaseInsensitive)) {
+if (!project->isActiveConfig("no_icon")) {
 t << QString("\"%1epoc32/data/z/resource/apps/%2\"    - \"%3\\%4\"")
 .arg(epocRoot())
 .arg(fixedTarget + ".rsc")
 .arg(installPathResource)
 .arg(fixedTarget + ".rsc") << endl;
 }
 }
 }
 // deploy any additional DEPLOYMENT  files
-DeploymentList depList;
 QString remoteTestPath;
 remoteTestPath = QString("!:\\private\\%1").arg(privateDirUid);
+QString zDir = epocRoot() + QLatin1String("epoc32/data/z");
 initProjectDeploySymbian(project, depList, remoteTestPath, true, "$(PLATFORM)", "$(TARGET)", generatedDirs, generatedFiles);
 if (depList.size())
 t << "; DEPLOYMENT" << endl;
 for (int i = 0; i < depList.size(); ++i)  {
-t << QString("\"%1\"    - \"%2\"")
+QString from = depList.at(i).from;
-.arg(QString(depList.at(i).from).replace('\\','/'))
+QString to = depList.at(i).to;
-.arg(depList.at(i).to) << endl;
+// Deploy anything not already deployed from under epoc32 instead from under
+// \epoc32\data\z\ to enable using pkg file without rebuilding
+// the project, which can be useful for some binary only distributions.
+if (!from.contains(QLatin1String("epoc32"), Qt::CaseInsensitive)) {
+from = to;
+if (from.size() > 1 && from.at(1) == QLatin1Char(':'))
+from = from.mid(2);
+from.prepend(zDir);
+} else {
+if (from.size() > 1 && from.at(1) == QLatin1Char(':'))
+from = from.mid(2);
+}
+t << QString("\"%1\"    - \"%2\"").arg(from.replace('\\','/')).arg(to) << endl;
 }
 t << endl;
 // PKG post-rules - these are added after actual file installations i.e. SIS package body
 t << "; Manual PKG post-rules from PRO files" << endl;
 }
 }
 t << endl;
 }
 }
+// Close Manufacturer block
+if (!project->values("DEPLOYMENT.manufacturers").isEmpty()) {
+QString manufacturerFailNoteFile;
+if (project->values("DEPLOYMENT.manufacturers.fail_note").isEmpty()) {
+manufacturerFailNoteFile = QString("%1_" MANUFACTURER_NOTE_FILE).arg(uid3);
+QFile ft(manufacturerFailNoteFile);
+if (ft.open(QIODevice::WriteOnly)) {
+generatedFiles << ft.fileName();
+QTextStream t2(&ft);
+t2 << QString(DEFAULT_MANUFACTURER_NOTE) << endl;
+} else {
+PRINT_FILE_CREATE_ERROR(manufacturerFailNoteFile)
+}
+} else {
+manufacturerFailNoteFile = project->values("DEPLOYMENT.manufacturers.fail_note").join("");
+}
+t << "ELSEIF NOT(0) ; MANUFACTURER" << endl
+<< "\"" << fileInfo(manufacturerFailNoteFile).absoluteFilePath() << "\""
+<< " - \"\", FILETEXT, TEXTEXIT" << endl
+<< "ENDIF ; MANUFACTURER" << endl;
+}
+// Write wrapper pkg
+if (!installerSisHeader.isEmpty()) {
+QFile wrapperPkgFile(wrapperPkgFilename);
+if (!wrapperPkgFile.open(QIODevice::WriteOnly | QIODevice::Text)) {
+PRINT_FILE_CREATE_ERROR(wrapperPkgFilename);
+return;
+}
+generatedFiles << wrapperPkgFile.fileName();
+QTextStream twf(&wrapperPkgFile);
+twf << wrapperStreamBuffer << endl;
+// Wrapped files deployment
+QString currentPath = qmake_getpwd();
+QString sisName = QString("%1.sis").arg(fixedTarget);
+twf << "\"" << currentPath << "/" << sisName << "\" - \"c:\\adm\\" << sisName << "\"" << endl;
+QString bootStrapPath = QLibraryInfo::location(QLibraryInfo::PrefixPath);
+bootStrapPath.append("/smartinstaller.sis");
+QFileInfo fi(fileInfo(bootStrapPath));
+twf << "@\"" << fi.absoluteFilePath() << "\",(0x2002CCCD)" << endl;
+}
 }
 bool SymbianMakefileGenerator::containsStartWithItem(const QChar &c, const QStringList& src)
 {
 bool result = false;
 return result;
 }
 void SymbianMakefileGenerator::writeCustomDefFile()
 {
-if (targetType == TypePlugin && !project->values("CONFIG").contains("stdbinary", Qt::CaseInsensitive)) {
+if (targetType == TypePlugin && !project->isActiveConfig("stdbinary")) {
 // Create custom def file for plugin
 QFile ft(QLatin1String(PLUGIN_COMMON_DEF_FILE_ACTUAL));
 if (ft.open(QIODevice::WriteOnly)) {
 if (Option::mkfile::listgen) {
 {
 MakefileGenerator::init();
 fixedTarget = escapeFilePath(fileFixify(project->first("TARGET")));
 fixedTarget = removePathSeparators(fixedTarget);
 removeSpecialCharacters(fixedTarget);
+		translationFileName = escapeFilePath(fileFixify(project->first("TRANSLATIONS")));
+		if (!translationFileName.isEmpty()){
+		 		translationFileName.chop(3);
+				translationFileName = removePathSeparators(translationFileName);
+				removeSpecialCharacters(translationFileName);
+			}
+			else
+				translationFileName = fixedTarget;
 if (0 != project->values("QMAKE_PLATFORM").size())
 platform = varGlue("QMAKE_PLATFORM", "", " ", "");
 if (0 == project->values("QMAKESPEC").size())
 if ((project->values("TEMPLATE")).contains("app"))
 targetType = TypeExe;
 else if ((project->values("TEMPLATE")).contains("lib")) {
 // Check CONFIG to see if we are to build staticlib or dll
-if (project->values("CONFIG").contains("staticlib") || project->values("CONFIG").contains("static"))
+if (project->isActiveConfig("staticlib") || project->isActiveConfig("static"))
 targetType = TypeLib;
-else if (project->values("CONFIG").contains("plugin"))
+else if (project->isActiveConfig("plugin"))
 targetType = TypePlugin;
 else
 targetType = TypeDll;
 } else {
 targetType = TypeSubdirs;
 }
 if (0 != project->values("TARGET.UID2").size()) {
 uid2 = project->first("TARGET.UID2");
-} else if (project->values("CONFIG").contains("stdbinary", Qt::CaseInsensitive)) {
+} else if (project->isActiveConfig("stdbinary")) {
 uid2 = "0x20004C45";
 } else {
 if (targetType == TypeExe) {
 if (project->values("QT").contains("gui", Qt::CaseInsensitive)) {
 // exe and gui -> uid2 needed
 srcpaths << project->values("SOURCES") << project->values("GENERATED_SOURCES");
 srcpaths << project->values("UNUSED_SOURCES") << project->values("UI_SOURCES_DIR");
 srcpaths << project->values("UI_DIR");
 QDir current = QDir::current();
-QString canonizedCurrent = canonizePath(".");
+QString absolutizedCurrent = absolutizePath(".");
 for (int j = 0; j < srcpaths.size(); ++j) {
 QFileInfo fi(fileInfo(srcpaths.at(j)));
 // Sometimes sources have other than *.c* files (e.g. *.moc); prune them.
 if (fi.suffix().startsWith("c")) {
 if (fi.filePath().length() > fi.fileName().length()) {
 appendIfnotExist(srcincpaths, fi.path());
-sources[canonizePath(fi.path())] += fi.fileName();
+sources[absolutizePath(fi.path())] += fi.fileName();
 } else {
-sources[canonizedCurrent] += fi.fileName();
+sources[absolutizedCurrent] += fi.fileName();
-appendIfnotExist(srcincpaths, canonizedCurrent);
+appendIfnotExist(srcincpaths, absolutizedCurrent);
 }
 }
 }
 QStringList incpaths;
 incpaths << srcincpaths;
 incpaths << project->values("UI_HEADERS_DIR");
 incpaths << project->values("UI_DIR");
 for (int j = 0; j < incpaths.size(); ++j) {
-QString includepath = canonizePath(incpaths.at(j));
+QString includepath = absolutizePath(incpaths.at(j));
 appendIfnotExist(sysincspaths, includepath);
 appendAbldTempDirs(sysincspaths, includepath);
 }
 // Remove duplicate include path entries
 QStringList overridableMmpKeywords;
 QStringList restrictableMmpKeywords;
 QStringList restrictedMmpKeywords;
 bool inResourceBlock = false;
-overridableMmpKeywords << QLatin1String(MMP_TARGETTYPE);
+overridableMmpKeywords << QLatin1String(MMP_TARGETTYPE) << QLatin1String(MMP_EPOCHEAPSIZE);
 restrictableMmpKeywords << QLatin1String(MMP_TARGET) << QLatin1String(MMP_SECUREID)
-<< QLatin1String(MMP_OPTION_CW) << QLatin1String(MMP_OPTION_ARMCC)
+<< QLatin1String(MMP_LINKEROPTION_CW) << QLatin1String(MMP_LINKEROPTION_ARMCC)
-<< QLatin1String(MMP_OPTION_GCCE) << QLatin1String(MMP_LINKEROPTION_CW)
+<< QLatin1String(MMP_LINKEROPTION_GCCE)
-<< QLatin1String(MMP_LINKEROPTION_ARMCC) << QLatin1String(MMP_LINKEROPTION_GCCE)
 << QLatin1String(MMP_CAPABILITY) << QLatin1String(MMP_EPOCALLOWDLLDATA)
-<< QLatin1String(MMP_EPOCHEAPSIZE) << QLatin1String(MMP_EPOCSTACKSIZE)
+<< QLatin1String(MMP_EPOCSTACKSIZE) << QLatin1String(MMP_UID)
-<< QLatin1String(MMP_UID) << QLatin1String(MMP_VENDORID)
+<< QLatin1String(MMP_VENDORID) << QLatin1String(MMP_VERSION);
-<< QLatin1String(MMP_VERSION);
 foreach (QString item, project->values("MMP_RULES")) {
 if (project->values(item).isEmpty()) {
 handleMmpRulesOverrides(item, inResourceBlock, restrictedMmpKeywords,
 restrictableMmpKeywords, overridableMmpKeywords);
 }
 t << endl;
 }
 t << endl;
-if (!project->values("CONFIG").contains("static") && !project->values("CONFIG").contains("staticlib")) {
+if (!project->isActiveConfig("static") && !project->isActiveConfig("staticlib")) {
 writeMmpFileLibraryPart(t);
 }
 writeMmpFileCapabilityPart(t);
 void SymbianMakefileGenerator::writeMmpFileTargetPart(QTextStream& t)
 {
 bool skipTargetType = overriddenMmpKeywords.contains(MMP_TARGETTYPE);
+bool skipEpocHeapSize = overriddenMmpKeywords.contains(MMP_EPOCHEAPSIZE);
 if (targetType == TypeExe) {
 t << MMP_TARGET "\t\t" << fixedTarget << ".exe" << endl;
 if (!skipTargetType) {
-if (project->values("CONFIG").contains("stdbinary", Qt::CaseInsensitive))
+if (project->isActiveConfig("stdbinary"))
 t << MMP_TARGETTYPE "\t\tSTDEXE" << endl;
 else
 t << MMP_TARGETTYPE "\t\tEXE" << endl;
 }
 } else if (targetType == TypeDll || targetType == TypePlugin) {
 t << MMP_TARGET "\t\t" << fixedTarget << ".dll" << endl;
 if (!skipTargetType) {
-if (project->values("CONFIG").contains("stdbinary", Qt::CaseInsensitive))
+if (project->isActiveConfig("stdbinary"))
 t << MMP_TARGETTYPE "\t\tSTDDLL" << endl;
 else
 t << MMP_TARGETTYPE "\t\tDLL" << endl;
 }
 } else if (targetType == TypeLib) {
 t << MMP_TARGET "\t\t" << fixedTarget << ".lib" << endl;
 if (!skipTargetType) {
-if (project->values("CONFIG").contains("stdbinary", Qt::CaseInsensitive))
+if (project->isActiveConfig("stdbinary"))
 t << MMP_TARGETTYPE "\t\tSTDLIB" << endl;
 else
 t << MMP_TARGETTYPE "\t\tLIB" << endl;
 }
 } else {
 t << endl;
 if (0 != project->first("TARGET.EPOCSTACKSIZE").size())
 t << MMP_EPOCSTACKSIZE "\t\t" << project->first("TARGET.EPOCSTACKSIZE") << endl;
-if (0 != project->values("TARGET.EPOCHEAPSIZE").size())
+if (!skipEpocHeapSize && 0 != project->values("TARGET.EPOCHEAPSIZE").size())
 t << MMP_EPOCHEAPSIZE "\t\t" << project->values("TARGET.EPOCHEAPSIZE").join(" ") << endl;
 if (0 != project->values("TARGET.EPOCALLOWDLLDATA").size())
 t << MMP_EPOCALLOWDLLDATA << endl;
-if (targetType == TypePlugin && !project->values("CONFIG").contains("stdbinary", Qt::CaseInsensitive)) {
+if (targetType == TypePlugin && !project->isActiveConfig("stdbinary")) {
 // Use custom def file for Qt plugins
 t << "DEFFILE " PLUGIN_COMMON_DEF_FILE_FOR_MMP << endl;
 }
 t << endl;
 \private\10003a3f\import\apps directory.
 */
 void SymbianMakefileGenerator::writeMmpFileResourcePart(QTextStream& t, QStringList &symbianLangCodes)
 {
 if ((targetType == TypeExe) &&
-!project->values("CONFIG").contains("no_icon", Qt::CaseInsensitive)) {
+!project->isActiveConfig("no_icon")) {
 QString locTarget = fixedTarget;
 locTarget.append(".rss");
 t << "SOURCEPATH\t\t\t. " << endl;
 if (!cw.isEmpty())
 t << MMP_OPTION_CW " " << cw <<  endl;
 if (!armcc.isEmpty())
 t << MMP_OPTION_ARMCC " " << armcc <<  endl;
+foreach(QString armccVersion, project->values("VERSION_FLAGS.ARMCC")) {
+QStringList currentValues = project->values("QMAKE_CXXFLAGS." + armccVersion);
+if (currentValues.size()) {
+t << "#if defined(" << armccVersion << ")" << endl;
+t << MMP_OPTION_ARMCC " " << currentValues.join(" ") <<  endl;
+t << "#endif" << endl;
+}
+}
 if (!gcce.isEmpty())
 t << MMP_OPTION_GCCE " " << gcce <<  endl;
 if (!cwlink.isEmpty())
 t << MMP_LINKEROPTION_CW " " << cwlink <<  endl;
 }
 }
 }
 }
-void SymbianMakefileGenerator::writeBldInfContent(QTextStream &t, bool addDeploymentExtension, const QString &iconFile)
+void SymbianMakefileGenerator::writeBldInfContent(QTextStream &t, bool addDeploymentExtension, const QString &iconFile, DeploymentList &depList)
 {
 // Read user defined bld inf rules
 QMap<QString, QStringList> userBldInfRules;
 for (QMap<QString, QStringList>::iterator it = project->variables().begin(); it != project->variables().end(); ++it) {
 } else if (!project->isEmpty(item + ".subdir")) {
 fixedItem = project->first(item + ".subdir");
 } else {
 fixedItem = item;
 }
+QString condition;
+if (!project->isEmpty(item + ".condition"))
+condition = project->first(item + ".condition");
 QFileInfo subdir(fileInfo(fixedItem));
 QString relativePath = directory.relativeFilePath(fixedItem);
 QString subdirFileName = subdir.completeBaseName();
 QString fullProName = subdir.absoluteFilePath();;
 QString uid = generate_uid(fullProName);
 QString bldinfDefine = QString("BLD_INF_") + subdirFileName + QString("_") + uid;
 bldinfDefine = bldinfDefine.toUpper();
 removeSpecialCharacters(bldinfDefine);
+if (!condition.isEmpty())
+t << "#if defined(" << condition << ")" << endl;
 t << "#ifndef " << bldinfDefine << endl;
-t << "\t#include \"" << QDir::toNativeSeparators(bldinfFilename) << "\"" << endl;
+t << "\t#include \"" << bldinfFilename << "\"" << endl;
-t << "#endif // " << bldinfDefine << endl;
+t << "#endif" << endl;
+if (!condition.isEmpty())
+t << "#endif" << endl;
 }
 // Add supported project platforms
 t << endl << BLD_INF_TAG_PLATFORMS << endl << endl;
 t << endl;
 // Add project mmps and old style extension makefiles
 QString mmpTag;
-if (project->values("CONFIG").contains("symbian_test", Qt::CaseInsensitive))
+if (project->isActiveConfig(SYMBIAN_TEST_CONFIG))
 mmpTag = QLatin1String(BLD_INF_TAG_TESTMMPFILES);
 else
 mmpTag = QLatin1String(BLD_INF_TAG_MMPFILES);
 t << endl << mmpTag << endl << endl;
 userItems = userBldInfRules.value(mmpTag);
 foreach(QString item, userItems)
 t << item << endl;
 userBldInfRules.remove(mmpTag);
-t << endl << BLD_INF_TAG_EXTENSIONS << endl << endl;
+QString extensionTag;
+if (project->isActiveConfig(SYMBIAN_TEST_CONFIG))
+extensionTag = QLatin1String(BLD_INF_TAG_TESTEXTENSIONS);
+else
+extensionTag = QLatin1String(BLD_INF_TAG_EXTENSIONS);
+t << endl << extensionTag << endl << endl;
 // Generate extension rules
 writeBldInfExtensionRulesPart(t, iconFile);
-userItems = userBldInfRules.value(BLD_INF_TAG_EXTENSIONS);
+userItems = userBldInfRules.value(extensionTag);
 foreach(QString item, userItems)
 t << item << endl;
-userBldInfRules.remove(BLD_INF_TAG_EXTENSIONS);
+userBldInfRules.remove(extensionTag);
 // Add rest of the user defined content
 for (QMap<QString, QStringList>::iterator it = userBldInfRules.begin(); it != userBldInfRules.end(); ++it) {
 t << endl << endl << it.key() << endl << endl;
 userItems = it.value();
 foreach(QString item, userItems)
 t << item << endl;
 }
-if (project->values("CONFIG").contains("headerexport", Qt::CaseInsensitive)) {
+}
-writeExportPart(t);
-}
+void SymbianMakefileGenerator::writeRegRssFile(QMap<QString, QStringList> &userItems)
-}
-void SymbianMakefileGenerator::writeExportPart(QTextStream &t)
-{
-QDir currentDir = QDir::current();
-t << "prj_exports" << endl;
-foreach(QString install, project->values("INSTALLS")) {
-QString installDir = project->first(install + ".path");
-// Export macros are the recommended way, but might not be used
-// in all cases (such as Qt headers). We handle it either way,
-// macros or not.
-bool useLayerMacro = false;
-if (installDir.startsWith("MW_LAYER_") ||
-installDir.startsWith("APP_LAYER_") ||
-installDir.startsWith("APP_LAYER_")) {
-useLayerMacro = true;
-} else {
-#ifdef Q_OS_WIN
-// If we are running on Windows, and the export target starts
-// with a drive letter, we need to remove it, the build tools
-// cannot handle drives in export paths
-if (installDir.length() > 2 && installDir[1] == ':') {
-installDir.remove(0, 2);
-}
-#endif
-installDir.replace("\\", "/");
-if (!installDir.endsWith("/")) {
-installDir.append("/");
-}
-}
-foreach(QString target, project->values(install + ".files")) {
-// Handle glob targets (only in the current directory)
-if (target.contains("*") || target.contains("?")) {
-QDir globber = QDir::current();
-globber.setNameFilters(QStringList(target));
-foreach(QString globbedTarget, globber.entryList()) {
-if (useLayerMacro) {
-QFileInfo globbedInfo(globbedTarget);
-t << globbedTarget << " " << installDir <<
-"(" << globbedInfo.fileName() << ")" << endl;
-} else {
-t << globbedTarget << " " << installDir <<
-globbedTarget << endl;
-}
-}
-} else {
-target = currentDir.relativeFilePath(target);
-QFileInfo targetInfo(target);
-// Not possible to export whole directories, extension makefile needed for this
-// Note that this check requires the file to be exported to exist in the qmake phase!
-if (targetInfo.isFile()) {
-if (useLayerMacro) {
-t << target << " " << installDir <<
-"(" << targetInfo.fileName() << ")" << endl;
-} else {
-t << target << " " << installDir <<
-targetInfo.fileName() << endl;
-}
-}
-}
-}
-}
-t << endl;
-}
-void SymbianMakefileGenerator::writeRegRssFile(QStringList &userItems)
 {
 QString filename(fixedTarget);
 filename.append("_reg.rss");
 QFile ft(filename);
 if (ft.open(QIODevice::WriteOnly)) {
 t << "// * user." << endl;
 t << "// ============================================================================" << endl;
 t << endl;
 t << "#include <" << fixedTarget << ".rsg>" << endl;
 t << "#include <appinfo.rh>" << endl;
+foreach(QString item, userItems[RSS_TAG_HEADER])
+t << item << endl;
 t << endl;
 t << "UID2 KUidAppRegistrationResourceFile" << endl;
 t << "UID3 " << uid3 << endl << endl;
 t << "RESOURCE APP_REGISTRATION_INFO" << endl;
 t << "\t{" << endl;
 t << "\tapp_file=\"" << fixedTarget << "\";" << endl;
 t << "\tlocalisable_resource_file=\"" RESOURCE_DIRECTORY_RESOURCE << fixedTarget << "\";" << endl;
+writeRegRssList(t, userItems[RSS_TAG_SERVICE_LIST],
+QLatin1String(RSS_TAG_SERVICE_LIST),
+QLatin1String("SERVICE_INFO"));
+writeRegRssList(t, userItems[RSS_TAG_FILE_OWNERSHIP_LIST],
+QLatin1String(RSS_TAG_FILE_OWNERSHIP_LIST),
+QLatin1String("FILE_OWNERSHIP_INFO"));
+writeRegRssList(t, userItems[RSS_TAG_DATATYPE_LIST],
+QLatin1String(RSS_TAG_DATATYPE_LIST),
+QLatin1String("DATATYPE"));
 t << endl;
-foreach(QString item, userItems)
+foreach(QString item, userItems[RSS_TAG_DEFAULT])
-t << "\t" << item << endl;
+t << "\t" << item.replace("\n","\n\t") << endl;
 t << "\t}" << endl;
+foreach(QString item, userItems[RSS_TAG_FOOTER])
+t << item << endl;
 } else {
 PRINT_FILE_CREATE_ERROR(filename)
+}
+}
+void SymbianMakefileGenerator::writeRegRssList(QTextStream &t,
+QStringList &userList,
+const QString &listTag,
+const QString &listItem)
+{
+int itemCount = userList.count();
+if (itemCount) {
+t << "\t" << listTag << " ="<< endl;
+t << "\t\t{" << endl;
+foreach(QString item, userList) {
+t << "\t\t" << listItem << endl;
+t << "\t\t\t{" << endl;
+t << "\t\t\t" << item.replace("\n","\n\t\t\t") << endl;
+t << "\t\t\t}";
+if (--itemCount)
+t << ",";
+t << endl;
+}
+t << "\t\t}; "<< endl;
 }
 }
 void SymbianMakefileGenerator::writeRssFile(QString &numberOfIcons, QString &iconFile)
 {
 t << "// * This file is generated by qmake and should not be modified by the" << endl;
 t << "// * user." << endl;
 t << "// ============================================================================" << endl;
 t << endl;
 t << "#include <appinfo.rh>" << endl;
-if (!project->values("SYMBIANTRANSLATIONS").isEmpty())
+t << "#include <" << translationFileName << ".loc>" << endl;
-t << "#include <" << fixedTarget << ".loc>" << endl;
-else
-t << "#include \"" << fixedTarget << ".loc\"" << endl;
 t << endl;
 t << "RESOURCE LOCALISABLE_APP_INFO r_localisable_app_info" << endl;
 t << "\t{" << endl;
 t << "\tshort_caption = STRING_r_short_caption;" << endl;
 t << "\tcaption_and_icon =" << endl;
 }
 }
 void SymbianMakefileGenerator::writeLocFile(QStringList &symbianLangCodes)
 {
-QString filename(fixedTarget);
+QString filename(translationFileName);
 if (project->values("SYMBIANTRANSLATIONS").isEmpty()) {
 filename.append(".loc");
 } else {
 if (!project->first("SYMBIANLOCFILESDIR").isEmpty()) {
 filename.insert(0,project->first("SYMBIANLOCFILESDIR"));
 } else {
-filename.insert(0,"/epoc32/include/platform/app/loc/");
+filename.insert(0,"/epoc32/include/platform/mw/loc/");
 }
 filename.append(".loc");
 }
 QFile ft(filename);
 t << "#define STRING_r_short_caption \"" << fixedTarget  << "\"" << endl;
 t << "#define STRING_r_caption \"" << fixedTarget  << "\"" << endl;
 t << "#endif" << endl;
 } else {
 t << "#if LANGUAGE_01" << endl;
-t << "#include <" << "01/" << fixedTarget  << "_01.loc>" << endl;
+t << "#include <" << "01/" << translationFileName  << "_01.loc>" << endl;
 foreach(QString lang, symbianLangCodes) {
 if (lang.localeAwareCompare("01") != 0) {
 t << "#elif LANGUAGE_" << lang << endl;
-t << "#include <" << lang << "/" << fixedTarget  << "_" << lang << ".loc>" << ">" << endl;
+t << "#include <" << lang << "/" << translationFileName  << "_" << lang << ".loc" << ">" << endl;
 }
 }
 t << "#endif" << endl;
 }
 } else {
 }
 }
 void SymbianMakefileGenerator::writeSymbianLocFile(QStringList &symbianLangCodes)
 {
-	QString filename(fixedTarget);
+	QString filename(translationFileName);
 	foreach(QString lang, symbianLangCodes) {
 		QString tsFilename(filename);
 		QString language = qt2S60LangMapTable.key(lang, QString("en"));
 		tsFilename.append("_"+language+".ts");
-		tsFilename.insert(0,project->first("SYMBIANTRANSLATIONDIR"));
+		tsFilename.insert(0,project->first("SYMBIANTRANSLATIONSRCDIR"));
 QString locFilename(filename);
 locFilename.append("_"+lang+".loc");
 if (!project->first("SYMBIANLOCFILESDIR").isEmpty()) {
 locFilename.insert(0,lang+"/");
 locFilename.insert(0,project->first("SYMBIANLOCFILESDIR"));
 } else {
-locFilename.insert(0,"/epoc32/include/platform/app/loc/"+lang+"/");
+locFilename.insert(0,"/epoc32/include/platform/mw/loc/"+lang+"/");
 }
 QString shortCaption;
 QString longCaption;
 }
 }
 }
 }
 }
-if (shortCaption.isEmpty())
+if (shortCaption.isEmpty()){
 fprintf(stderr, "Warning: STRING_r_short_caption not generated from file '%s'.\n", qPrintable(tsFilename));
-if (longCaption.isEmpty())
+fprintf(stderr, "       : short caption generated from target name '#%s'.\n", qPrintable(fixedTarget));
+}
+if (longCaption.isEmpty()){
 fprintf(stderr, "Warning: STRING_r_caption not generated from file '%s'.\n", qPrintable(tsFilename));
+fprintf(stderr, "       : caption generated from target name '#%s'.\n", qPrintable(fixedTarget));
+}
 if (xml.hasError())
 fprintf(stderr, "ERROR: \"%s\" when parsing ts file\n", qPrintable(xml.errorString()));
 } else {
 fprintf(stderr, "Could not open ts file (%s)\n", qPrintable(tsFilename));
 }
 } else {
-fprintf(stderr, "ts file does not exist: (%s)\n", qPrintable(tsFilename));
+fprintf(stderr, "Warning: ts file does not exist: (%s)\n", qPrintable(tsFilename));
+fprintf(stderr, "       : short and long caption generated from target name '#%s'.\n", qPrintable(fixedTarget));
 }
 // generate language specific caption loc file
 QFile ft(locFilename);
 if (ft.open(QIODevice::WriteOnly)) {
 t << "// ============================================================================" << endl;
 t << endl;
 if (!shortCaption.isEmpty()) {
 t << "#define STRING_r_short_caption \"" << shortCaption  << "\"" << endl;
 } else {
-t << "#define STRING_r_short_caption \"" << fixedTarget  << "\"" << endl;
+t << "#define STRING_r_short_caption \"" "#"<< fixedTarget  << "\"" << endl;
 }
 if (!longCaption.isEmpty()) {
 t << "#define STRING_r_caption \"" << longCaption  << "\"" << endl;
 } else {
-t << "#define STRING_r_caption \"" << fixedTarget  << "\"" << endl;
+t << "#define STRING_r_caption \"" "#"<< fixedTarget  << "\"" << endl;
 }
 ft.close();
 } else {
 PRINT_FILE_CREATE_ERROR(locFilename);
 	    }
 }
 }
-void SymbianMakefileGenerator::readRssRules(QString &numberOfIcons, QString &iconFile, QStringList &userRssRules)
+void SymbianMakefileGenerator::readRssRules(QString &numberOfIcons,
+QString &iconFile, QMap<QString,
+QStringList> &userRssRules)
 {
 for (QMap<QString, QStringList>::iterator it = project->variables().begin(); it != project->variables().end(); ++it) {
 if (it.key().startsWith(RSS_RULES_BASE)) {
 QString newKey = it.key().mid(sizeof(RSS_RULES_BASE) - 1);
 if (newKey.isEmpty()) {
 continue;
 }
 QStringList newValues;
 QStringList values = it.value();
 foreach(QString item, values) {
-// If there is no stringlist defined for a rule, use rule name directly
+// If there is no stringlist defined for a rule, use rule value directly
 // This is convenience for defining single line statements
 if (project->values(item).isEmpty()) {
 newValues << item;
 } else {
+QStringList itemList;
 foreach(QString itemRow, project->values(item)) {
-newValues << itemRow;
+itemList << itemRow;
 }
+newValues << itemList.join("\n");
 }
 }
 // Verify thet there is exactly one value in RSS_TAG_NBROFICONS
 if (newKey == RSS_TAG_NBROFICONS) {
 if (newValues.count() == 1) {
 } else {
 fprintf(stderr, "Warning: There must be exactly one value in '%s%s'\n",
 RSS_RULES_BASE, RSS_TAG_ICONFILE);
 continue;
 }
+} else if (newKey == RSS_TAG_HEADER
+|| newKey == RSS_TAG_SERVICE_LIST
+|| newKey == RSS_TAG_FILE_OWNERSHIP_LIST
+|| newKey == RSS_TAG_DATATYPE_LIST
+|| newKey == RSS_TAG_FOOTER
+|| newKey == RSS_TAG_DEFAULT) {
+userRssRules[newKey] = newValues;
+continue;
 } else {
 fprintf(stderr, "Warning: Unsupported key:'%s%s'\n",
 RSS_RULES_BASE, newKey.toLatin1().constData());
 continue;
 }
 }
 }
+QStringList newValues;
 foreach(QString item, project->values(RSS_RULES)) {
-// If there is no stringlist defined for a rule, use rule name directly
+// If there is no stringlist defined for a rule, use rule value directly
-// This is convenience for defining single line mmp statements
+// This is convenience for defining single line statements
 if (project->values(item).isEmpty()) {
-userRssRules << item;
+newValues << item;
 } else {
-userRssRules << project->values(item);
+newValues << project->values(item);
 }
 }
+userRssRules[RSS_TAG_DEFAULT] << newValues;
 // Validate that either both RSS_TAG_NBROFICONS and RSS_TAG_ICONFILE keys exist
 // or neither of them exist
 if (!((numberOfIcons.isEmpty() && iconFile.isEmpty()) ||
 (!numberOfIcons.isEmpty() && !iconFile.isEmpty()))) {
 // Validate that RSS_TAG_NBROFICONS contains only numbers
 if (!numberOfIcons.isEmpty()) {
 bool ok;
 numberOfIcons = numberOfIcons.simplified();
-int tmp = numberOfIcons.toInt(&ok);
+numberOfIcons.toInt(&ok);
 if (!ok) {
 numberOfIcons.clear();
 iconFile.clear();
 fprintf(stderr, "Warning: '%s%s' must be integer in decimal format.\n",
 RSS_RULES_BASE, RSS_TAG_NBROFICONS);
 str.replace(QString(" "), QString("_"));
 }
 void SymbianMakefileGenerator::writeSisTargets(QTextStream &t)
 {
-t << SIS_TARGET ": " RESTORE_BUILD_TARGET << endl;
+t << "-include " MAKE_CACHE_NAME << endl;
-QString siscommand = QString("\t$(if $(wildcard %1_template.%2),$(if $(wildcard %3)," \
+t << endl;
-"$(MAKE) -s -f $(MAKEFILE) %4,$(MAKE) -s -f $(MAKEFILE) %5)," \
+t << SIS_TARGET ":" << endl;
+QString siscommand = QString::fromLatin1("\t$(if $(wildcard %1_template.%2),$(if $(wildcard %3)," \
+"$(MAKE) -s -f $(MAKEFILE) %4," \
+"$(if $(QT_SIS_TARGET),$(MAKE) -s -f $(MAKEFILE) %4," \
+"$(MAKE) -s -f $(MAKEFILE) %5))," \
 "$(MAKE) -s -f $(MAKEFILE) %6)")
 .arg(fixedTarget)
 .arg("pkg")
 .arg(MAKE_CACHE_NAME)
 .arg(OK_SIS_TARGET)
 t << siscommand << endl;
 t << endl;
 t << OK_SIS_TARGET ":" << endl;
-QString pkgcommand = QString("\tcreatepackage.bat $(QT_SIS_OPTIONS) %1_template.%2 $(QT_SIS_TARGET) " \
+QString pkgcommand = QString::fromLatin1("\tcreatepackage.bat $(QT_SIS_OPTIONS) %1_template.%2 $(QT_SIS_TARGET) " \
 "$(QT_SIS_CERTIFICATE) $(QT_SIS_KEY) $(QT_SIS_PASSPHRASE)")
 .arg(fixedTarget)
 .arg("pkg");
 t << pkgcommand << endl;
 t << endl;
+QString sisName = fixedTarget;
+sisName += ".sis";
+t << sisName << ":" << endl;
+t << "\t$(MAKE) -s -f $(MAKEFILE) " SIS_TARGET << endl << endl;
+t << ROM_STUB_SIS_TARGET ":" << endl;
+QString stubsiscommand = QString::fromLatin1("\t$(if $(wildcard %1_template.%2),$(if $(wildcard %3)," \
+"$(MAKE) -s -f $(MAKEFILE) %4," \
+"$(if $(QT_SIS_TARGET),$(MAKE) -s -f $(MAKEFILE) %4," \
+"$(MAKE) -s -f $(MAKEFILE) %5))," \
+"$(MAKE) -s -f $(MAKEFILE) %6)")
+.arg(fixedTarget)
+.arg("pkg")
+.arg(MAKE_CACHE_NAME)
+.arg(OK_ROM_STUB_SIS_TARGET)
+.arg(FAIL_SIS_NOCACHE_TARGET)
+.arg(FAIL_SIS_NOPKG_TARGET);
+t << stubsiscommand << endl;
+t << endl;
+t << OK_ROM_STUB_SIS_TARGET ":" << endl;
+QString stubpkgcommand = QString::fromLatin1("\tcreatepackage.bat -s $(QT_SIS_OPTIONS) %1_template.%2 $(QT_SIS_TARGET) " \
+"$(QT_SIS_CERTIFICATE) $(QT_SIS_KEY) $(QT_SIS_PASSPHRASE)")
+.arg(fixedTarget)
+.arg("pkg");
+t << stubpkgcommand << endl;
+t << endl;
+t << INSTALLER_SIS_TARGET ": " << sisName << endl;
+siscommand = QString::fromLatin1("\t$(if $(wildcard %1_installer.%2)," \
+"$(MAKE) -s -f $(MAKEFILE) %3," \
+"$(MAKE) -s -f $(MAKEFILE) %4)")
+.arg(fixedTarget)
+.arg("pkg")
+.arg(OK_INSTALLER_SIS_TARGET)
+.arg(FAIL_SIS_NOPKG_TARGET);
+t << siscommand << endl;
+t << endl;
+t << OK_INSTALLER_SIS_TARGET ": " << endl;
+pkgcommand = QString::fromLatin1("\tcreatepackage.bat $(QT_SIS_OPTIONS) %1_installer.%2 - " \
+"$(QT_SIS_CERTIFICATE) $(QT_SIS_KEY) $(QT_SIS_PASSPHRASE)")
+.arg(fixedTarget)
+.arg("pkg");
+t << pkgcommand << endl;
+t << endl;
 t << FAIL_SIS_NOPKG_TARGET ":" << endl;
-t << "\t$(error PKG file does not exist, 'SIS' target is only supported for executables or projects with DEPLOYMENT statement)" << endl;
+t << "\t$(error PKG file does not exist, '" SIS_TARGET "' and '" INSTALLER_SIS_TARGET "' target are only supported for executables or projects with DEPLOYMENT statement)" << endl;
 t << endl;
 t << FAIL_SIS_NOCACHE_TARGET ":" << endl;
-t << "\t$(error Project has to be build before calling 'SIS' target)" << endl;
+t << "\t$(error Project has to be built or QT_SIS_TARGET environment variable has to be set before calling 'SIS' target)" << endl;
-t << endl;
-t << RESTORE_BUILD_TARGET ":" << endl;
-t << "-include " MAKE_CACHE_NAME << endl;
 t << endl;
 }
 void SymbianMakefileGenerator::generateDistcleanTargets(QTextStream& t)
 {
 t << endl;
 t << "distclean: clean dodistclean" << endl;
 t << endl;
 }
+void SymbianMakefileGenerator::generateExecutionTargets(QTextStream& t, const QStringList& platforms)
+{
+// create execution targets
+if (targetType == TypeExe) {
+if (platforms.contains("winscw")) {
+t << "run:" << endl;
+t << "\t-call " << epocRoot() << "epoc32/release/winscw/udeb/" << fixedTarget << ".exe " << "$(QT_RUN_OPTIONS)" << endl;
+}
+t << "runonphone: sis" << endl;
+t << "\trunonphone $(QT_RUN_ON_PHONE_OPTIONS) --sis " << fixedTarget << ".sis " << fixedTarget << ".exe " << "$(QT_RUN_OPTIONS)" << endl;
+t << endl;
+}
+}

changeset 7	f7bc934e204c
parent 3	41300fa6a67c