/****************************************************************************
**
** 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_BEGIN_LICENSE:LGPL$
** No Commercial Usage
** This file contains pre-release code and may not be distributed.
** You may use this file in accordance with the terms and conditions
** contained in the Technology Preview License Agreement accompanying
** this package.
**
** GNU Lesser General Public License Usage
** Alternatively, 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.
**
** If you have questions regarding the use of this file, please contact
** Nokia at qt-info@nokia.com.
**
**
**
**
**
**
**
**
** $QT_END_LICENSE$
**
****************************************************************************/
#include "symmake.h"
#include <qstring.h>
#include <qhash.h>
#include <qstringlist.h>
#include <qdir.h>
#include <qdatetime.h>
#include <stdlib.h>
#include <qdebug.h>
#include <QSettings>
// Included from tools/shared
#include <symbian/epocroot.h>
#define RESOURCE_DIRECTORY_MMP "/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 MMP_TARGET "TARGET"
#define MMP_TARGETTYPE "TARGETTYPE"
#define MMP_SECUREID "SECUREID"
#define MMP_OPTION "OPTION"
#define MMP_LINKEROPTION "LINKEROPTION"
#define MMP_CAPABILITY "CAPABILITY"
#define MMP_EPOCALLOWDLLDATA "EPOCALLOWDLLDATA"
#define MMP_EPOCHEAPSIZE "EPOCHEAPSIZE"
#define MMP_EPOCSTACKSIZE "EPOCSTACKSIZE"
#define MMP_UID "UID"
#define MMP_VENDORID "VENDORID"
#define MMP_VERSION "VERSION"
#define MMP_START_RESOURCE "START RESOURCE"
#define MMP_END_RESOURCE "END"
#define VAR_CXXFLAGS "QMAKE_CXXFLAGS"
#define VAR_CFLAGS "QMAKE_CFLAGS"
#define VAR_LFLAGS "QMAKE_LFLAGS"
QString SymbianMakefileGenerator::fixPathForMmp(const QString& origPath, const QDir& parentDir)
{
static QString epocRootStr;
if (epocRootStr.isEmpty()) {
epocRootStr = epocRoot();
QFileInfo efi(epocRootStr);
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/";
}
QString resultPath = origPath;
// Make it relative, unless it starts with "%epocroot%/epoc32/"
if (resultPath.startsWith(epocRootStr, Qt::CaseInsensitive)) {
resultPath.replace(epocRootStr, "/epoc32/", Qt::CaseInsensitive);
} else {
resultPath = parentDir.relativeFilePath(resultPath);
}
resultPath = QDir::cleanPath(resultPath);
if (resultPath.isEmpty())
resultPath = ".";
return resultPath;
}
QString SymbianMakefileGenerator::absolutizePath(const QString& origPath)
{
// Prepend epocroot to any paths beginning with "/epoc32/"
QString resultPath = QDir::fromNativeSeparators(origPath);
if (resultPath.startsWith("/epoc32/", Qt::CaseInsensitive))
resultPath = QDir::fromNativeSeparators(epocRoot()) + resultPath.mid(1);
QFileInfo fi(fileInfo(resultPath));
// Since origPath can be something given in HEADERS, we need to check if we are dealing
// with a file or a directory. In case the origPath doesn't yet exist, isFile() returns
// false and we default to assuming it is a dir.
if (fi.isFile()) {
resultPath = fi.absolutePath();
} else {
resultPath = fi.absoluteFilePath();
}
resultPath = QDir::cleanPath(resultPath);
return resultPath;
}
SymbianMakefileGenerator::SymbianMakefileGenerator() : MakefileGenerator(), SymbianCommonGenerator(this) { }
SymbianMakefileGenerator::~SymbianMakefileGenerator() { }
void SymbianMakefileGenerator::writeHeader(QTextStream &t)
{
t << "// ============================================================================" << endl;
t << "// * Makefile for building: " << escapeFilePath(var("TARGET")) << endl;
t << "// * Generated by qmake (" << qmake_version() << ") (Qt " QT_VERSION_STR ") on: ";
t << QDateTime::currentDateTime().toString(Qt::ISODate) << endl;
t << "// * This file is generated by qmake and should not be modified by the" << endl;
t << "// * user." << endl;
t << "// * Project: " << fileFixify(project->projectFile()) << endl;
t << "// * Template: " << var("TEMPLATE") << endl;
t << "// ============================================================================" << endl;
t << endl;
// Defining define for bld.inf
QString shortProFilename = project->projectFile();
shortProFilename.replace(0, shortProFilename.lastIndexOf("/") + 1, QString(""));
shortProFilename.replace(Option::pro_ext, QString(""));
QString bldinfDefine = shortProFilename;
bldinfDefine.append("_");
bldinfDefine.append(generate_uid(project->projectFile()));
bldinfDefine.prepend("BLD_INF_");
removeEpocSpecialCharacters(bldinfDefine);
t << "#define " << bldinfDefine.toUpper() << endl << endl;
}
bool SymbianMakefileGenerator::writeMakefile(QTextStream &t)
{
if(!project->values("QMAKE_FAILED_REQUIREMENTS").isEmpty()) {
fprintf(stderr, "Project files not generated because all requirements are not met:\n\t%s\n",
qPrintable(var("QMAKE_FAILED_REQUIREMENTS")));
return false;
}
writeHeader(t);
QString numberOfIcons;
QString iconFile;
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;
if (targetType == TypeExe) {
generatePkg = true;
} else {
foreach(QString item, project->values("DEPLOYMENT")) {
if (!project->values(item + ".sources").isEmpty()) {
generatePkg = true;
break;
}
}
}
if (generatePkg) {
generatePkgFile(iconFile, true);
}
writeBldInfContent(t, generatePkg, iconFile);
// 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 = Option::output_dir + QLatin1Char('/') + QLatin1String("Makefile");
QString outputFileName = fileInfo(Option::output.fileName()).fileName();
if (outputFileName != BLD_INF_FILENAME) {
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)) {
generatedFiles << wrapperFileName;
if (Option::mkfile::listgen) {
generatePrint(fileInfo(wrapperMakefile.fileName()).absoluteFilePath());
}
} else {
PRINT_FILE_CREATE_ERROR(wrapperFileName);
return false;
}
if (targetType == TypeSubdirs) {
// If we have something to deploy, generate extension makefile for just that, since
// normal extension makefile is not getting generated and we need emulator deployment to be done.
if (generatePkg)
writeMkFile(wrapperFileName, true);
writeWrapperMakefile(wrapperMakefile, isPrimaryMakefile);
return true;
}
writeMkFile(wrapperFileName, false);
QString shortProFilename = project->projectFile();
shortProFilename.replace(0, shortProFilename.lastIndexOf("/") + 1, QString(""));
shortProFilename.replace(Option::pro_ext, QString(""));
QString mmpFilename = Option::output_dir + QLatin1Char('/') + shortProFilename + QLatin1Char('_')
+ uid3 + Option::mmp_ext;
writeMmpFile(mmpFilename, symbianLangCodes);
if (targetType == TypeExe) {
if (!project->isActiveConfig("no_icon")) {
writeRegRssFile(userRssRules);
writeRssFile(numberOfIcons, iconFile);
writeLocFile(symbianLangCodes);
if (!project->values("SYMBIANTRANSLATIONS").isEmpty())
writeSymbianLocFile(symbianLangCodes);
}
}
writeCustomDefFile();
writeWrapperMakefile(wrapperMakefile, isPrimaryMakefile);
return true;
}
void SymbianMakefileGenerator::writeCustomDefFile()
{
if (targetType == TypePlugin && !project->isActiveConfig("stdbinary")) {
// Create custom def file for plugin
QFile ft(Option::output_dir + QLatin1Char('/') + QLatin1String(PLUGIN_COMMON_DEF_FILE_ACTUAL));
if (ft.open(QIODevice::WriteOnly)) {
if (Option::mkfile::listgen) {
generatePrint(fileInfo(ft.fileName()).absoluteFilePath());
}
generatedFiles << ft.fileName();
QTextStream t(&ft);
t << "; ==============================================================================" << endl;
t << "; Generated by qmake (" << qmake_version() << ") (Qt " QT_VERSION_STR ") on: ";
t << QDateTime::currentDateTime().toString(Qt::ISODate) << endl;
t << "; This file is generated by qmake and should not be modified by the" << endl;
t << "; user." << endl;
t << "; Name : " PLUGIN_COMMON_DEF_FILE_ACTUAL << endl;
t << "; Part of : " << project->values("TARGET").join(" ") << endl;
t << "; Description : Fixes common plugin symbols to known ordinals" << endl;
t << "; Version : " << endl;
t << ";" << endl;
t << "; ==============================================================================" << "\n" << endl;
t << endl;
t << "EXPORTS" << endl;
t << "\tqt_plugin_query_verification_data @ 1 NONAME" << endl;
t << "\tqt_plugin_instance @ 2 NONAME" << endl;
t << endl;
} else {
PRINT_FILE_CREATE_ERROR(QString(PLUGIN_COMMON_DEF_FILE_ACTUAL))
}
}
}
void SymbianMakefileGenerator::init()
{
MakefileGenerator::init();
SymbianCommonGenerator::init();
if (0 != project->values("QMAKE_PLATFORM").size())
platform = varGlue("QMAKE_PLATFORM", "", " ", "");
if (0 == project->values("QMAKESPEC").size())
project->values("QMAKESPEC").append(qgetenv("QMAKESPEC"));
project->values("QMAKE_LIBS") += escapeFilePaths(project->values("LIBS"));
project->values("QMAKE_LIBS_PRIVATE") += escapeFilePaths(project->values("LIBS_PRIVATE"));
// bld.inf
project->values("MAKEFILE") += BLD_INF_FILENAME;
// .mmp
initMmpVariables();
uid2 = project->first("TARGET.UID2");
uid2 = uid2.trimmed();
}
QString SymbianMakefileGenerator::getTargetExtension()
{
QString ret;
if (targetType == TypeExe) {
ret.append("exe");
} else if (targetType == TypeLib) {
ret.append("lib");
} else if (targetType == TypeDll || targetType == TypePlugin) {
ret.append("dll");
} else if (targetType == TypeSubdirs) {
// Not actually usable, so return empty
} else {
// If nothing else set, default to exe
ret.append("exe");
}
return ret;
}
QString SymbianMakefileGenerator::generateUID3()
{
QString target = project->first("TARGET");
QString currPath = qmake_getpwd();
target.prepend("/").prepend(currPath);
return generate_test_uid(target);
}
void SymbianMakefileGenerator::initMmpVariables()
{
QStringList sysincspaths;
QStringList srcincpaths;
QStringList srcpaths;
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 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[absolutizePath(fi.path())] += fi.fileName();
} else {
sources[absolutizedCurrent] += fi.fileName();
appendIfnotExist(srcincpaths, absolutizedCurrent);
}
}
}
QStringList incpaths;
incpaths << project->values("INCLUDEPATH");
incpaths << QLibraryInfo::location(QLibraryInfo::HeadersPath);
incpaths << project->values("HEADERS");
incpaths << srcincpaths;
incpaths << project->values("UI_HEADERS_DIR");
incpaths << project->values("UI_DIR");
for (int j = 0; j < incpaths.size(); ++j) {
QString includepath = absolutizePath(incpaths.at(j));
appendIfnotExist(sysincspaths, includepath);
appendAbldTempDirs(sysincspaths, includepath);
}
// Remove duplicate include path entries
QStringList temporary;
for (int i = 0; i < sysincspaths.size(); ++i) {
QString origPath = sysincspaths.at(i);
QFileInfo origPathInfo(fileInfo(origPath));
bool bFound = false;
for (int j = 0; j < temporary.size(); ++j) {
QString tmpPath = temporary.at(j);
QFileInfo tmpPathInfo(fileInfo(tmpPath));
if (origPathInfo.absoluteFilePath() == tmpPathInfo.absoluteFilePath()) {
bFound = true;
if (!tmpPathInfo.isRelative() && origPathInfo.isRelative()) {
// We keep the relative notation
temporary.removeOne(tmpPath);
temporary << origPath;
}
}
}
if (!bFound)
temporary << origPath;
}
sysincspaths.clear();
sysincspaths << temporary;
systeminclude.insert("SYSTEMINCLUDE", sysincspaths);
// Check MMP_RULES for singleton keywords that are overridden
QStringList overridableMmpKeywords;
QStringList restrictableMmpKeywords;
QStringList restrictedMmpKeywords;
bool inResourceBlock = false;
overridableMmpKeywords << QLatin1String(MMP_TARGETTYPE) << QLatin1String(MMP_EPOCHEAPSIZE);
restrictableMmpKeywords << QLatin1String(MMP_TARGET) << QLatin1String(MMP_SECUREID)
<< QLatin1String(MMP_OPTION) << QLatin1String(MMP_LINKEROPTION)
<< QLatin1String(MMP_CAPABILITY) << QLatin1String(MMP_EPOCALLOWDLLDATA)
<< QLatin1String(MMP_EPOCSTACKSIZE) << QLatin1String(MMP_UID)
<< QLatin1String(MMP_VENDORID) << QLatin1String(MMP_VERSION);
foreach (QString item, project->values("MMP_RULES")) {
if (project->values(item).isEmpty()) {
handleMmpRulesOverrides(item, inResourceBlock, restrictedMmpKeywords,
restrictableMmpKeywords, overridableMmpKeywords);
} else {
foreach (QString itemRow, project->values(item)) {
handleMmpRulesOverrides(itemRow, inResourceBlock, restrictedMmpKeywords,
restrictableMmpKeywords, overridableMmpKeywords);
}
}
}
if (restrictedMmpKeywords.size()) {
fprintf(stderr, "Warning: Restricted statements detected in MMP_RULES:\n"
" (%s)\n"
" Use corresponding qmake variable(s) instead.\n",
qPrintable(restrictedMmpKeywords.join(", ")));
}
}
void SymbianMakefileGenerator::handleMmpRulesOverrides(QString &checkString,
bool &inResourceBlock,
QStringList &restrictedMmpKeywords,
const QStringList &restrictableMmpKeywords,
const QStringList &overridableMmpKeywords)
{
QString simplifiedString = checkString.simplified();
if (!inResourceBlock && simplifiedString.startsWith(MMP_START_RESOURCE, Qt::CaseInsensitive))
inResourceBlock = true;
else if (inResourceBlock && simplifiedString.startsWith(MMP_END_RESOURCE, Qt::CaseInsensitive))
inResourceBlock = false;
// Allow restricted and overridable items in RESOURCE blocks as those do not actually
// override anything.
if (!inResourceBlock) {
appendKeywordIfMatchFound(overriddenMmpKeywords, overridableMmpKeywords, simplifiedString);
appendKeywordIfMatchFound(restrictedMmpKeywords, restrictableMmpKeywords, simplifiedString);
}
}
void SymbianMakefileGenerator::appendKeywordIfMatchFound(QStringList &list,
const QStringList &keywordList,
QString &checkString)
{
// Check if checkString starts with any supplied keyword and
// add the found keyword to list if it does.
foreach (QString item, keywordList) {
if (checkString.startsWith(QString(item).append(" "), Qt::CaseInsensitive)
|| checkString.compare(item, Qt::CaseInsensitive) == 0) {
appendIfnotExist(list, item);
}
}
}
bool SymbianMakefileGenerator::removeDuplicatedStrings(QStringList &stringList)
{
QStringList tmpStringList;
for (int i = 0; i < stringList.size(); ++i) {
QString string = stringList.at(i);
if (tmpStringList.contains(string))
continue;
else
tmpStringList.append(string);
}
stringList.clear();
stringList = tmpStringList;
return true;
}
void SymbianMakefileGenerator::writeMmpFileHeader(QTextStream &t)
{
t << "// ==============================================================================" << endl;
t << "// Generated by qmake (" << qmake_version() << ") (Qt " QT_VERSION_STR ") on: ";
t << QDateTime::currentDateTime().toString(Qt::ISODate) << endl;
t << "// This file is generated by qmake and should not be modified by the" << endl;
t << "// user." << endl;
t << "// Name : " << escapeFilePath(fileFixify(project->projectFile().remove(project->projectFile().length() - 4, 4))) << Option::mmp_ext << endl;
t << "// ==============================================================================" << endl << endl;
}
void SymbianMakefileGenerator::writeMmpFile(QString &filename, QStringList &symbianLangCodes)
{
QFile ft(filename);
if (ft.open(QIODevice::WriteOnly)) {
if (Option::mkfile::listgen) {
generatePrint(fileInfo(ft.fileName()).absoluteFilePath());
}
generatedFiles << ft.fileName();
QTextStream t(&ft);
writeMmpFileHeader(t);
writeMmpFileTargetPart(t);
writeMmpFileResourcePart(t, symbianLangCodes);
writeMmpFileMacrosPart(t);
writeMmpFileIncludePart(t);
QDir current = QDir::current();
for (QMap<QString, QStringList>::iterator it = sources.begin(); it != sources.end(); ++it) {
QStringList values = it.value();
QString currentSourcePath = it.key();
if (values.size())
t << "SOURCEPATH \t" << fixPathForMmp(currentSourcePath, current) << endl;
for (int i = 0; i < values.size(); ++i) {
QString sourceFileName = values.at(i);
t << "SOURCE\t\t" << sourceFileName << endl;
}
t << endl;
}
t << endl;
if (!project->isActiveConfig("static") && !project->isActiveConfig("staticlib")) {
writeMmpFileLibraryPart(t);
}
writeMmpFileCapabilityPart(t);
writeMmpFileCompilerOptionPart(t);
writeMmpFileBinaryVersionPart(t);
writeMmpFileRulesPart(t);
} else {
PRINT_FILE_CREATE_ERROR(filename)
}
}
void SymbianMakefileGenerator::writeMmpFileMacrosPart(QTextStream& t)
{
t << endl;
QStringList &defines = project->values("DEFINES");
if (defines.size())
t << "// Qt Macros" << endl;
for (int i = 0; i < defines.size(); ++i) {
QString def = defines.at(i);
addMacro(t, def);
}
// These are required in order that all methods will be correctly exported e.g from qtestlib
QStringList &exp_defines = project->values("PRL_EXPORT_DEFINES");
if (exp_defines.size())
t << endl << "// Qt Export Defines" << endl;
for (int i = 0; i < exp_defines.size(); ++i) {
QString def = exp_defines.at(i);
addMacro(t, def);
}
t << endl;
}
void SymbianMakefileGenerator::addMacro(QTextStream& t, const QString& value)
{
t << "MACRO\t\t" << value << endl;
}
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->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->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->isActiveConfig("stdbinary"))
t << MMP_TARGETTYPE "\t\tSTDLIB" << endl;
else
t << MMP_TARGETTYPE "\t\tLIB" << endl;
}
} else {
fprintf(stderr, "Error: Unexpected targettype (%d) in SymbianMakefileGenerator::writeMmpFileTargetPart\n", targetType);
}
t << endl;
t << MMP_UID "\t\t" << uid2 << " " << uid3 << endl;
if (0 != project->values("TARGET.SID").size()) {
t << MMP_SECUREID "\t\t" << project->values("TARGET.SID").join(" ") << endl;
} else {
if (0 == uid3.size())
t << MMP_SECUREID "\t\t0" << endl;
else
t << MMP_SECUREID "\t\t" << uid3 << endl;
}
// default value used from mkspecs is 0
if (0 != project->values("TARGET.VID").size()) {
t << MMP_VENDORID "\t\t" << project->values("TARGET.VID").join(" ") << endl;
}
t << endl;
if (0 != project->first("TARGET.EPOCSTACKSIZE").size())
t << MMP_EPOCSTACKSIZE "\t\t" << project->first("TARGET.EPOCSTACKSIZE") << endl;
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->isActiveConfig("stdbinary")) {
// Use custom def file for Qt plugins
t << "DEFFILE " PLUGIN_COMMON_DEF_FILE_FOR_MMP << endl;
}
t << endl;
}
/*
Application registration resource files should be installed to the
\private\10003a3f\import\apps directory.
*/
void SymbianMakefileGenerator::writeMmpFileResourcePart(QTextStream& t, QStringList &symbianLangCodes)
{
if ((targetType == TypeExe) &&
!project->isActiveConfig("no_icon")) {
QString locTarget = fixedTarget;
locTarget.append(".rss");
t << "SOURCEPATH\t\t\t. " << endl;
//QTP: org 47 start
/* t << "LANG SC "; // no endl
foreach(QString lang, symbianLangCodes) {
t << lang << " "; // no endl
}
t << endl;
t << MMP_START_RESOURCE "\t\t" << locTarget << endl;
t << "HEADER" << endl;
t << "TARGETPATH\t\t\t" RESOURCE_DIRECTORY_MMP << endl;
t << MMP_END_RESOURCE << endl << endl;*/
//QTP: org 47 end
//QTP: loc change start
if (!project->values("SYMBIANTRANSLATIONS").isEmpty()) {
t << MMP_START_RESOURCE "\t\t" << locTarget << endl;
t << "LANGUAGE_IDS" << endl;
t << "HEADER" << endl;
t << "TARGETPATH\t\t\t" RESOURCE_DIRECTORY_MMP << endl;
t << MMP_END_RESOURCE << endl << endl;
} else {
t << "LANG SC "; // no endl
foreach(QString lang, symbianLangCodes) {
t << lang << " "; // no endl
}
t << endl;
t << MMP_START_RESOURCE "\t\t" << locTarget << endl;
t << "HEADER" << endl;
t << "TARGETPATH\t\t\t" RESOURCE_DIRECTORY_MMP << endl;
t << MMP_END_RESOURCE << endl << endl;
}
//QTP: loc change end
QString regTarget = fixedTarget;
regTarget.append("_reg.rss");
t << "SOURCEPATH\t\t\t." << endl;
t << MMP_START_RESOURCE "\t\t" << regTarget << endl;
if (isForSymbianSbsv2())
t << "DEPENDS " << fixedTarget << ".rsg" << endl;
t << "TARGETPATH\t\t" REGISTRATION_RESOURCE_DIRECTORY_HW << endl;
t << MMP_END_RESOURCE << endl << endl;
}
}
void SymbianMakefileGenerator::writeMmpFileSystemIncludePart(QTextStream& t)
{
QDir current = QDir::current();
for (QMap<QString, QStringList>::iterator it = systeminclude.begin(); it != systeminclude.end(); ++it) {
QStringList values = it.value();
for (int i = 0; i < values.size(); ++i) {
QString handledPath = values.at(i);
t << "SYSTEMINCLUDE\t\t" << fixPathForMmp(handledPath, current) << endl;
}
}
t << endl;
}
void SymbianMakefileGenerator::writeMmpFileIncludePart(QTextStream& t)
{
writeMmpFileSystemIncludePart(t);
}
void SymbianMakefileGenerator::writeMmpFileLibraryPart(QTextStream& t)
{
QStringList &libs = project->values("LIBS");
libs << project->values("QMAKE_LIBS") << project->values("QMAKE_LIBS_PRIVATE");
removeDuplicatedStrings(libs);
for (int i = 0; i < libs.size(); ++i) {
QString lib = libs.at(i);
// The -L flag is uninteresting, since all symbian libraries exist in the same directory.
if (lib.startsWith("-l")) {
lib.remove(0, 2);
QString mmpStatement;
if (lib.endsWith(".dll")) {
lib.chop(4);
mmpStatement = "LIBRARY\t\t";
} else if (lib.endsWith(".lib")) {
lib.chop(4);
mmpStatement = "STATICLIBRARY\t";
} else {
// Hacky way to find out what kind of library it is. Check the
// ARMV5 build directory for library type. We default to shared
// library, since that is more common.
QString udebStaticLibLocation(epocRoot());
QString urelStaticLibLocation(udebStaticLibLocation);
udebStaticLibLocation += QString("epoc32/release/armv5/udeb/%1.lib").arg(lib);
urelStaticLibLocation += QString("epoc32/release/armv5/urel/%1.lib").arg(lib);
if (QFile::exists(udebStaticLibLocation) || QFile::exists(urelStaticLibLocation)) {
mmpStatement = "STATICLIBRARY\t";
} else {
mmpStatement = "LIBRARY\t\t";
}
}
t << mmpStatement << lib << ".lib" << endl;
}
}
t << endl;
}
void SymbianMakefileGenerator::writeMmpFileCapabilityPart(QTextStream& t)
{
if (0 != project->first("TARGET.CAPABILITY").size()) {
QStringList &capabilities = project->values("TARGET.CAPABILITY");
t << MMP_CAPABILITY "\t\t";
for (int i = 0; i < capabilities.size(); ++i) {
QString cap = capabilities.at(i);
t << cap << " ";
}
} else {
t << MMP_CAPABILITY "\t\tNone";
}
t << endl << endl;
}
void SymbianMakefileGenerator::writeMmpFileConditionalOptions(QTextStream& t,
const QString &optionType,
const QString &optionTag,
const QString &variableBase)
{
foreach(QString compilerVersion, project->values("VERSION_FLAGS." + optionTag)) {
QStringList currentValues = project->values(variableBase + "." + compilerVersion);
if (currentValues.size()) {
t << "#if defined(" << compilerVersion << ")" << endl;
t << optionType << " " << optionTag << " " << currentValues.join(" ") << endl;
t << "#endif" << endl;
}
}
}
void SymbianMakefileGenerator::writeMmpFileSimpleOption(QTextStream& t,
const QString &optionType,
const QString &optionTag,
const QString &options)
{
QString trimmedOptions = options.trimmed();
if (!trimmedOptions.isEmpty())
t << optionType << " " << optionTag << " " << trimmedOptions << endl;
}
void SymbianMakefileGenerator::appendMmpFileOptions(QString &options, const QStringList &list)
{
if (list.size()) {
options.append(list.join(" "));
options.append(" ");
}
}
void SymbianMakefileGenerator::writeMmpFileCompilerOptionPart(QTextStream& t)
{
QStringList keywords = project->values("MMP_OPTION_KEYWORDS");
QStringList commonCxxFlags = project->values(VAR_CXXFLAGS);
QStringList commonCFlags = project->values(VAR_CFLAGS);
QStringList commonLFlags = project->values(VAR_LFLAGS);
foreach(QString item, keywords) {
QString compilerOption;
QString linkerOption;
appendMmpFileOptions(compilerOption, project->values(VAR_CXXFLAGS "." + item));
appendMmpFileOptions(compilerOption, project->values(VAR_CFLAGS "." + item));
appendMmpFileOptions(compilerOption, commonCxxFlags);
appendMmpFileOptions(compilerOption, commonCFlags);
appendMmpFileOptions(linkerOption, project->values(VAR_LFLAGS "." + item));
appendMmpFileOptions(linkerOption, commonLFlags);
writeMmpFileSimpleOption(t, MMP_OPTION, item, compilerOption);
writeMmpFileSimpleOption(t, MMP_LINKEROPTION, item, linkerOption);
writeMmpFileConditionalOptions(t, MMP_OPTION, item, VAR_CXXFLAGS);
writeMmpFileConditionalOptions(t, MMP_LINKEROPTION, item, VAR_LFLAGS);
}
t << endl;
}
void SymbianMakefileGenerator::writeMmpFileBinaryVersionPart(QTextStream& t)
{
QString applicationVersion = project->first("VERSION");
QStringList verNumList = applicationVersion.split('.');
uint major = 0;
uint minor = 0;
uint patch = 0;
bool success = false;
if (verNumList.size() > 0) {
major = verNumList[0].toUInt(&success);
if (success && verNumList.size() > 1) {
minor = verNumList[1].toUInt(&success);
if (success && verNumList.size() > 2) {
patch = verNumList[2].toUInt(&success);
}
}
}
QString mmpVersion;
if (success && major <= 0xFFFF && minor <= 0xFF && patch <= 0xFF) {
// Symbian binary version only has major and minor components, so compress
// Qt's minor and patch values into the minor component. Since Symbian's minor
// component is a 16 bit value, only allow 8 bits for each to avoid overflow.
mmpVersion.append(QString::number(major))
.append('.')
.append(QString::number((minor << 8) + patch));
} else {
if (!applicationVersion.isEmpty())
fprintf(stderr, "Invalid VERSION string: %s\n", qPrintable(applicationVersion));
mmpVersion = "10.0"; // Default binary version for symbian is 10.0
}
t << MMP_VERSION " " << mmpVersion << endl;
}
void SymbianMakefileGenerator::writeMmpFileRulesPart(QTextStream& t)
{
foreach(QString item, project->values("MMP_RULES")) {
t << endl;
// If there is no stringlist defined for a rule, use rule name directly
// This is convenience for defining single line mmp statements
if (project->values(item).isEmpty()) {
t << item << endl;
} else {
foreach(QString itemRow, project->values(item)) {
t << itemRow << endl;
}
}
}
}
void SymbianMakefileGenerator::writeBldInfContent(QTextStream &t, bool addDeploymentExtension, const QString &iconFile)
{
// Read user defined bld inf rules
QMap<QString, QStringList> userBldInfRules;
for (QMap<QString, QStringList>::iterator it = project->variables().begin(); it != project->variables().end(); ++it) {
if (it.key().startsWith(BLD_INF_RULES_BASE)) {
QString newKey = it.key().mid(sizeof(BLD_INF_RULES_BASE) - 1);
if (newKey.isEmpty()) {
fprintf(stderr, "Warning: Empty BLD_INF_RULES key encountered\n");
continue;
}
QStringList newValues;
QStringList values = it.value();
foreach(QString item, values) {
// If there is no stringlist defined for a rule, use rule name directly
// This is convenience for defining single line statements
if (project->values(item).isEmpty()) {
newValues << item;
} else {
foreach(QString itemRow, project->values(item)) {
newValues << itemRow;
}
}
}
userBldInfRules.insert(newKey, newValues);
}
}
// Add includes of subdirs bld.inf files
QString mmpfilename = escapeFilePath(fileFixify(project->projectFile()));
mmpfilename = mmpfilename.replace(mmpfilename.lastIndexOf("."), 4, Option::mmp_ext);
QString currentPath = qmake_getpwd();
QDir directory(currentPath);
const QStringList &subdirs = project->values("SUBDIRS");
foreach(QString item, subdirs) {
QString fixedItem;
if (!project->isEmpty(item + ".file")) {
fixedItem = project->first(item + ".file");
} 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 bldinfFilename;
if (subdir.isDir()) {
// Subdir is a regular project
bldinfFilename = relativePath + QString("/") + QString(BLD_INF_FILENAME);
fullProName += QString("/") + subdirFileName + Option::pro_ext;
} else {
// Subdir is actually a .pro file
if (relativePath.contains("/")) {
// .pro not in same directory as parent .pro
relativePath.remove(relativePath.lastIndexOf("/") + 1, relativePath.length());
bldinfFilename = relativePath;
} else {
// .pro and parent .pro in same directory
bldinfFilename = QString("./");
}
bldinfFilename += QString(BLD_INF_FILENAME ".") + subdirFileName;
}
QString uid = generate_uid(fullProName);
QString bldinfDefine = QString("BLD_INF_") + subdirFileName + QString("_") + uid;
bldinfDefine = bldinfDefine.toUpper();
removeEpocSpecialCharacters(bldinfDefine);
if (!condition.isEmpty())
t << "#if defined(" << condition << ")" << endl;
t << "#ifndef " << bldinfDefine << endl;
t << "\t#include \"" << bldinfFilename << "\"" << endl;
t << "#endif" << endl;
if (!condition.isEmpty())
t << "#endif" << endl;
}
// Add supported project platforms
t << endl << BLD_INF_TAG_PLATFORMS << endl << endl;
if (0 != project->values("SYMBIAN_PLATFORMS").size())
t << project->values("SYMBIAN_PLATFORMS").join(" ") << endl;
QStringList userItems = userBldInfRules.value(BLD_INF_TAG_PLATFORMS);
foreach(QString item, userItems)
t << item << endl;
userBldInfRules.remove(BLD_INF_TAG_PLATFORMS);
t << endl;
// Add project mmps and old style extension makefiles
QString mmpTag;
if (project->isActiveConfig(SYMBIAN_TEST_CONFIG))
mmpTag = QLatin1String(BLD_INF_TAG_TESTMMPFILES);
else
mmpTag = QLatin1String(BLD_INF_TAG_MMPFILES);
t << endl << mmpTag << endl << endl;
writeBldInfMkFilePart(t, addDeploymentExtension);
if (targetType != TypeSubdirs) {
QString shortProFilename = project->projectFile();
shortProFilename.replace(0, shortProFilename.lastIndexOf("/") + 1, QString(""));
shortProFilename.replace(Option::pro_ext, QString(""));
QString mmpFilename = shortProFilename + QString("_") + uid3 + Option::mmp_ext;
t << mmpFilename << endl;
}
userItems = userBldInfRules.value(mmpTag);
foreach(QString item, userItems)
t << item << endl;
userBldInfRules.remove(mmpTag);
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(extensionTag);
foreach(QString item, userItems)
t << item << endl;
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;
}
}
void SymbianMakefileGenerator::appendIfnotExist(QStringList &list, QString value)
{
if (!list.contains(value))
list += value;
}
void SymbianMakefileGenerator::appendIfnotExist(QStringList &list, QStringList values)
{
foreach(QString item, values)
appendIfnotExist(list, item);
}
QString SymbianMakefileGenerator::removeTrailingPathSeparators(QString &file)
{
QString ret = file;
if (ret.endsWith(QDir::separator())) {
ret.remove(ret.length() - 1, 1);
}
return ret;
}
void SymbianMakefileGenerator::generateCleanCommands(QTextStream& t,
const QStringList& toClean,
const QString& cmd,
const QString& cmdOptions,
const QString& itemPrefix,
const QString& itemSuffix)
{
for (int i = 0; i < toClean.size(); ++i) {
QString item = toClean.at(i);
item.prepend(itemPrefix).append(itemSuffix);
#if defined(Q_OS_WIN)
t << "\t-@ if EXIST \"" << QDir::toNativeSeparators(item) << "\" ";
t << cmd << " " << cmdOptions << " \"" << QDir::toNativeSeparators(item) << "\"" << endl;
#else
t << "\t-if test -e " << QDir::toNativeSeparators(item) << "; then ";
t << cmd << " " << cmdOptions << " " << QDir::toNativeSeparators(item) << "; fi" << endl;
#endif
}
}
void SymbianMakefileGenerator::generateDistcleanTargets(QTextStream& t)
{
t << "dodistclean:" << endl;
const QStringList &subdirs = project->values("SUBDIRS");
foreach(QString item, subdirs) {
bool fromFile = false;
QString fixedItem;
if (!project->isEmpty(item + ".file")) {
fixedItem = project->first(item + ".file");
fromFile = true;
} else if (!project->isEmpty(item + ".subdir")) {
fixedItem = project->first(item + ".subdir");
fromFile = false;
} else {
fromFile = item.endsWith(Option::pro_ext);
fixedItem = item;
}
QFileInfo fi(fileInfo(fixedItem));
if (!fromFile) {
t << "\t-$(MAKE) -f \"" << Option::fixPathToTargetOS(fi.absoluteFilePath() + "/Makefile") << "\" dodistclean" << endl;
} else {
QString itemName = fi.fileName();
int extIndex = itemName.lastIndexOf(Option::pro_ext);
if (extIndex)
fixedItem = fi.absolutePath() + "/" + QString("Makefile.") + itemName.mid(0, extIndex);
t << "\t-$(MAKE) -f \"" << Option::fixPathToTargetOS(fixedItem) << "\" dodistclean" << endl;
}
}
generatedFiles << Option::fixPathToTargetOS(fileInfo(Option::output.fileName()).absoluteFilePath()); // bld.inf
generatedFiles << project->values("QMAKE_INTERNAL_PRL_FILE"); // Add generated prl files for cleanup
generatedFiles << project->values("QMAKE_DISTCLEAN"); // Add any additional files marked for distclean
QStringList fixedFiles;
QStringList fixedDirs;
foreach(QString item, generatedFiles) {
QString fixedItem = Option::fixPathToTargetOS(fileInfo(item).absoluteFilePath());
if (!fixedFiles.contains(fixedItem)) {
fixedFiles << fixedItem;
}
}
foreach(QString item, generatedDirs) {
QString fixedItem = Option::fixPathToTargetOS(fileInfo(item).absoluteFilePath());
if (!fixedDirs.contains(fixedItem)) {
fixedDirs << fixedItem;
}
}
generateCleanCommands(t, fixedFiles, "$(DEL_FILE)", "", "", "");
generateCleanCommands(t, fixedDirs, "$(DEL_DIR)", "", "", "");
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;
}
}