Fix QMAKE_POST_LINK in Symbian for targets with special characters.
[qt:qt.git] / qmake / generators / symbian / symmake_sbsv2.cpp
1 /****************************************************************************
2 **
3 ** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4 ** All rights reserved.
5 ** Contact: Nokia Corporation (qt-info@nokia.com)
6 **
7 ** This file is part of the qmake application of the Qt Toolkit.
8 **
9 ** $QT_BEGIN_LICENSE:LGPL$
10 ** No Commercial Usage
11 ** This file contains pre-release code and may not be distributed.
12 ** You may use this file in accordance with the terms and conditions
13 ** contained in the Technology Preview License Agreement accompanying
14 ** this package.
15 **
16 ** GNU Lesser General Public License Usage
17 ** Alternatively, this file may be used under the terms of the GNU Lesser
18 ** General Public License version 2.1 as published by the Free Software
19 ** Foundation and appearing in the file LICENSE.LGPL included in the
20 ** packaging of this file.  Please review the following information to
21 ** ensure the GNU Lesser General Public License version 2.1 requirements
22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
23 **
24 ** In addition, as a special exception, Nokia gives you certain additional
25 ** rights.  These rights are described in the Nokia Qt LGPL Exception
26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
27 **
28 ** If you have questions regarding the use of this file, please contact
29 ** Nokia at qt-info@nokia.com.
30 **
31 **
32 **
33 **
34 **
35 **
36 **
37 **
38 ** $QT_END_LICENSE$
39 **
40 ****************************************************************************/
41
42 #include "symmake_sbsv2.h"
43 #include "initprojectdeploy_symbian.h"
44
45 #include <qstring.h>
46 #include <qstringlist.h>
47 #include <qdir.h>
48 #include <qdatetime.h>
49 #include <qdebug.h>
50
51 // Included from tools/shared
52 #include <symbian/epocroot_p.h>
53
54 SymbianSbsv2MakefileGenerator::SymbianSbsv2MakefileGenerator() : SymbianMakefileGenerator() { }
55 SymbianSbsv2MakefileGenerator::~SymbianSbsv2MakefileGenerator() { }
56
57 #define FLM_DEST_DIR "epoc32/tools/makefile_templates/qt"
58 #define FLM_SOURCE_DIR "/mkspecs/symbian-sbsv2/flm/qt"
59 #define PLATFORM_GCCE "gcce"
60 #define PLATFORM_WINSCW "winscw"
61 #define PLATFORM_ARM_PREFIX "arm"
62 #define BUILD_DEBUG "udeb"
63 #define BUILD_RELEASE "urel"
64 #define SBS_RVCT_PREFIX "rvct"
65
66 static QString winscwPlatform;
67 static QString armPlatformPrefix;
68 static QString gccePlatform;
69 static QString sbsRvctPrefix;
70
71 #if defined(Q_OS_UNIX)
72     extern char **environ;
73 #endif
74
75 static void fixFlmCmd(QString *cmdLine, const QMap<QString, QString> &commandsToReplace)
76 {
77     // If commandItem starts with any $$QMAKE_* commands, do a replace for SBS equivalent.
78     // Command replacement is done only for the start of the command or right after
79     // concatenation operators (&& and ||), as otherwise unwanted replacements might occur.
80     static QString cmdFind(QLatin1String("(^|&&\\s*|\\|\\|\\s*)%1"));
81     static QString cmdReplace(QLatin1String("\\1%1"));
82
83     // $$escape_expand(\\n\\t) doesn't work for bld.inf files, but is often used as command
84     // separator, so replace it with "&&" command concatenator.
85     cmdLine->replace("\n\t", "&&");
86
87     // Iterate command replacements in reverse alphabetical order of keys so
88     // that keys which are starts of other longer keys are iterated after longer keys.
89     QMapIterator<QString, QString> cmdIter(commandsToReplace);
90     cmdIter.toBack();
91     while (cmdIter.hasPrevious()) {
92         cmdIter.previous();
93         if (cmdLine->contains(cmdIter.key()))
94             cmdLine->replace(QRegExp(cmdFind.arg(cmdIter.key())), cmdReplace.arg(cmdIter.value()));
95     }
96
97     // Sbsv2 toolchain strips all backslashes (even double ones) from option parameters, so just
98     // assume all backslashes are directory separators and replace them with slashes.
99     // Problem: If some command actually needs backslashes for something else than dir separator,
100     // we are out of luck.
101     cmdLine->replace("\\", "/");
102 }
103
104 // Copies Qt FLMs to correct location under epocroot.
105 // This is not done by configure as it is possible to change epocroot after configure.
106 void SymbianSbsv2MakefileGenerator::exportFlm()
107 {
108     static bool flmExportDone = false;
109
110     if (!flmExportDone) {
111         QDir sourceDir = QDir(QLibraryInfo::location(QLibraryInfo::PrefixPath) + FLM_SOURCE_DIR);
112         QFileInfoList sourceInfos = sourceDir.entryInfoList(QDir::Files);
113
114         QDir destDir(qt_epocRoot() + FLM_DEST_DIR);
115         if (!destDir.exists()) {
116             if (destDir.mkpath(destDir.absolutePath()))
117                 generatedDirs << destDir.absolutePath();
118         }
119
120         foreach(QFileInfo item, sourceInfos) {
121             QFileInfo destInfo = QFileInfo(destDir.absolutePath() + "/" + item.fileName());
122             if (!destInfo.exists() || destInfo.lastModified() != item.lastModified()) {
123                 if (destInfo.exists())
124                     QFile::remove(destInfo.absoluteFilePath());
125                 if (QFile::copy(item.absoluteFilePath(), destInfo.absoluteFilePath()))
126                     generatedFiles << destInfo.absoluteFilePath();
127                 else
128                     fprintf(stderr, "Error: Could not copy '%s' -> '%s'\n",
129                             qPrintable(item.absoluteFilePath()),
130                             qPrintable(destInfo.absoluteFilePath()));
131             }
132         }
133         flmExportDone = true;
134     }
135 }
136
137 void SymbianSbsv2MakefileGenerator::findInstalledCompilerVersions(const QString &matchExpression,
138                                                                   const QString &versionPrefix,
139                                                                   QStringList *versionList)
140 {
141     // No need to be able to find env variables on other operating systems,
142     // as only linux and windows have support for symbian-sbsv2 toolchain
143 #if defined(Q_OS_UNIX) || defined(Q_OS_WIN)
144     char *entry = 0;
145     int count = 0;
146     QRegExp matcher(matchExpression);
147     while ((entry = environ[count++])) {
148         if (matcher.exactMatch(QString::fromLocal8Bit(entry))
149             && fileInfo(matcher.cap(matcher.captureCount())).exists()) {
150             // First capture (index 0) is the whole match, which is skipped.
151             // Next n captures are version numbers, which are interesting.
152             // Final capture is the env var value, which we already used, so that is skipped, too.
153             int capture = 1;
154             int finalCapture = matcher.captureCount() - 1;
155             QString version = versionPrefix;
156             while (capture <= finalCapture) {
157                 version.append(matcher.cap(capture));
158                 if (capture != finalCapture)
159                     version.append(QLatin1Char('.'));
160                 capture++;
161             }
162             *versionList << version;
163         }
164     }
165 #endif
166 }
167
168 void SymbianSbsv2MakefileGenerator::findGcceVersions(QStringList *gcceVersionList,
169                                                      QString *defaultVersion)
170 {
171     QString matchStr = QLatin1String("SBS_GCCE(\\d)(\\d)(\\d)BIN=(.*)");
172     findInstalledCompilerVersions(matchStr, gccePlatform, gcceVersionList);
173
174     QString qtGcceVersion = QString::fromLocal8Bit(qgetenv("QT_GCCE_VERSION"));
175
176     if (!qtGcceVersion.isEmpty()) {
177         if (QRegExp("\\d+\\.\\d+\\.\\d+").exactMatch(qtGcceVersion)) {
178             *defaultVersion = gccePlatform + qtGcceVersion;
179         } else {
180             fprintf(stderr, "Warning: Variable QT_GCCE_VERSION ('%s') is in incorrect "
181                     "format, expected format is: 'x.y.z'. Attempting to autodetect GCCE version.\n",
182                     qPrintable(qtGcceVersion));
183         }
184     }
185
186     if (defaultVersion->isEmpty() && gcceVersionList->size()) {
187         gcceVersionList->sort();
188         *defaultVersion = gcceVersionList->last();
189     }
190 }
191
192 void SymbianSbsv2MakefileGenerator::findRvctVersions(QStringList *rvctVersionList,
193                                                      QString *defaultVersion)
194 {
195     QString matchStr = QLatin1String("RVCT(\\d)(\\d)BIN=(.*)");
196     findInstalledCompilerVersions(matchStr, sbsRvctPrefix, rvctVersionList);
197
198     QString qtRvctVersion = QString::fromLocal8Bit(qgetenv("QT_RVCT_VERSION"));
199
200     if (!qtRvctVersion.isEmpty()) {
201         if (QRegExp("\\d+\\.\\d+").exactMatch(qtRvctVersion)) {
202             *defaultVersion = sbsRvctPrefix + qtRvctVersion;
203         } else {
204             fprintf(stderr, "Warning: Variable QT_RVCT_VERSION ('%s') is in incorrect "
205                     "format, expected format is: 'x.y'.\n",
206                     qPrintable(qtRvctVersion));
207         }
208     }
209 }
210
211 QString SymbianSbsv2MakefileGenerator::configClause(const QString &platform,
212                                                     const QString &build,
213                                                     const QString &compilerVersion,
214                                                     const QString &clauseTemplate)
215 {
216     QString retval;
217     if (QString::compare(platform, winscwPlatform) == 0) {
218         retval = clauseTemplate.arg(build);
219     } else if (platform.startsWith(armPlatformPrefix)) {
220         QString fixedCompilerVersion = compilerVersion;
221         fixedCompilerVersion.replace(".","_");
222         retval = clauseTemplate.arg(platform.mid(sizeof(PLATFORM_ARM_PREFIX)-1))
223                                   .arg(build)
224                                   .arg(fixedCompilerVersion);
225     } // else - Unsupported platform for makefile target, return empty clause
226     return retval;
227 }
228
229 void SymbianSbsv2MakefileGenerator::writeSbsDeploymentList(const DeploymentList& depList, QTextStream& t)
230 {
231     for (int i = 0; i < depList.size(); ++i) {
232         t << "START EXTENSION qt/qmake_emulator_deployment" << endl;
233         QString fromItem = depList.at(i).from;
234         QString toItem = depList.at(i).to;
235         fromItem.replace("\\", "/");
236         toItem.replace("\\", "/");
237 #if defined(Q_OS_WIN)
238         // add drive if it doesn't have one yet
239         if (toItem.size() > 1 && toItem[1] != QLatin1Char(':'))
240             toItem.prepend(QDir::current().absolutePath().left(2));
241 #endif
242         t << "OPTION DEPLOY_SOURCE " << fromItem << endl;
243         t << "OPTION DEPLOY_TARGET " << toItem << endl;
244         t << "END" << endl;
245     }
246 }
247
248 void SymbianSbsv2MakefileGenerator::writeMkFile(const QString& wrapperFileName, bool deploymentOnly)
249 {
250     // Can't use extension makefile with sbsv2
251     Q_UNUSED(wrapperFileName);
252     Q_UNUSED(deploymentOnly);
253 }
254
255 void SymbianSbsv2MakefileGenerator::writeWrapperMakefile(QFile& wrapperFile, bool isPrimaryMakefile)
256 {
257     static QString debugBuild;
258     static QString releaseBuild;
259     static QString defaultGcceCompilerVersion;
260     static QString defaultRvctCompilerVersion;
261     static QStringList rvctVersions;
262     static QStringList gcceVersions;
263     static QStringList allArmCompilerVersions;
264
265     // Initialize static variables used in makefile creation
266     if (debugBuild.isEmpty()) {
267         debugBuild.append(QLatin1String(BUILD_DEBUG));
268         releaseBuild.append(QLatin1String(BUILD_RELEASE));
269         winscwPlatform.append(QLatin1String(PLATFORM_WINSCW));
270         gccePlatform.append(QLatin1String(PLATFORM_GCCE));
271         armPlatformPrefix.append(QLatin1String(PLATFORM_ARM_PREFIX));
272         sbsRvctPrefix.append(QLatin1String(SBS_RVCT_PREFIX));
273
274         findGcceVersions(&gcceVersions, &defaultGcceCompilerVersion);
275         findRvctVersions(&rvctVersions, &defaultRvctCompilerVersion);
276
277         allArmCompilerVersions << rvctVersions << gcceVersions;
278
279         if (!allArmCompilerVersions.size()) {
280             fprintf(stderr, "Warning: No HW compilers detected. "
281                     "Please install either GCCE or RVCT compiler to enable release builds.\n");
282         }
283     }
284
285     QStringList allPlatforms;
286     foreach(QString platform, project->values("SYMBIAN_PLATFORMS")) {
287         allPlatforms << platform.toLower();
288     }
289
290     if (!gcceVersions.size())
291         allPlatforms.removeAll(gccePlatform);
292
293     QString testClause;
294     if (project->isActiveConfig(SYMBIAN_TEST_CONFIG))
295         testClause = QLatin1String(".test");
296     else
297         testClause = QLatin1String("");
298
299     // Note: armClause is used for gcce, too, which has a side effect
300     //       of requiring armv* platform(s) in SYMBIAN_PLATFORMS in order
301     //       to get any compiler version specific targets.
302     QString armClause = " -c " PLATFORM_ARM_PREFIX ".%1.%2.%3" + testClause;
303     QString genericArmClause;
304     if (defaultRvctCompilerVersion.isEmpty()) {
305         // Note: Argument %3 needs to be empty string in this version of clause
306         genericArmClause = " -c " PLATFORM_ARM_PREFIX "%1_%2%3" + testClause;
307     } else {
308         // If defaultRvctCompilerVersion is defined, use specific sbs clause for "generic" clause
309         genericArmClause = armClause;
310     }
311     QString winscwClause = " -c " PLATFORM_WINSCW "_%1.mwccinc" + testClause;;
312
313     QStringList armPlatforms = allPlatforms.filter(QRegExp("^" PLATFORM_ARM_PREFIX));
314
315     if (!allArmCompilerVersions.size()) {
316         foreach (QString item, armPlatforms) {
317             allPlatforms.removeAll(item);
318         }
319         armPlatforms.clear();
320     }
321
322     QStringList allClauses;
323     QStringList debugClauses;
324     QStringList releaseClauses;
325
326     // Only winscw and arm platforms are supported
327     QStringList debugPlatforms = allPlatforms;
328     QStringList releasePlatforms = allPlatforms;
329     releasePlatforms.removeAll(winscwPlatform); // No release for emulator
330
331     if (!releasePlatforms.size()) {
332         fprintf(stderr, "Warning: No valid release platforms in SYMBIAN_PLATFORMS (%s)\n"
333                 "Most likely required compiler(s) are not properly installed.\n",
334                 qPrintable(project->values("SYMBIAN_PLATFORMS").join(" ")));
335     }
336
337     if (debugPlatforms.contains(winscwPlatform))
338         debugClauses << configClause(winscwPlatform, debugBuild, QString(), winscwClause);
339
340     foreach(QString item, armPlatforms) {
341         // Only use single clause per arm platform even if multiple compiler versions were found,
342         // otherwise we get makefile target collisions from sbsv2 toolchain.
343         if (rvctVersions.size()) {
344             debugClauses << configClause(item, debugBuild, defaultRvctCompilerVersion, genericArmClause);
345             releaseClauses << configClause(item, releaseBuild, defaultRvctCompilerVersion, genericArmClause);
346         } else {
347             debugClauses << configClause(item, debugBuild, defaultGcceCompilerVersion, armClause);
348             releaseClauses << configClause(item, releaseBuild, defaultGcceCompilerVersion, armClause);
349         }
350     }
351
352     allClauses << debugClauses << releaseClauses;
353
354     QTextStream t(&wrapperFile);
355
356     MakefileGenerator::writeHeader(t);
357
358     t << "MAKEFILE          = " << fileInfo(wrapperFile.fileName()).fileName() << endl;
359     t << "QMAKE             = " << var("QMAKE_QMAKE") << endl;
360     t << "DEL_FILE          = " << var("QMAKE_DEL_FILE") << endl;
361     t << "DEL_DIR           = " << var("QMAKE_DEL_DIR") << endl;
362     t << "CHK_DIR_EXISTS    = " << var("QMAKE_CHK_DIR_EXISTS") << endl;
363     t << "MKDIR             = " << var("QMAKE_MKDIR") << endl;
364     t << "MOVE              = " << var("QMAKE_MOVE") << endl;
365     t << "DEBUG_PLATFORMS   = " << debugPlatforms.join(" ") << endl;
366     t << "RELEASE_PLATFORMS = " << releasePlatforms.join(" ") << endl;
367     t << "MAKE              = make" << endl;
368     t << "SBS               = sbs" << endl;
369     t << endl;
370     t << "DEFINES" << '\t' << " = "
371         << varGlue("PRL_EXPORT_DEFINES","-D"," -D"," ")
372         << varGlue("QMAKE_COMPILER_DEFINES", "-D", "-D", " ")
373         << varGlue("DEFINES","-D"," -D","") << endl;
374
375     t << "INCPATH" << '\t' << " = ";
376
377     for (QMap<QString, QStringList>::iterator it = systeminclude.begin(); it != systeminclude.end(); ++it) {
378         QStringList values = it.value();
379         for (int i = 0; i < values.size(); ++i) {
380             t << " -I\"" << values.at(i) << "\" ";
381         }
382     }
383
384     t << endl;
385     t << "first: default" << endl << endl;
386     if (!isPrimaryMakefile) {
387         t << "all:" << endl << endl;
388         t << "default: all" << endl << endl;
389     } else {
390         t << "all: debug release" << endl << endl;
391         if (debugPlatforms.contains(winscwPlatform))
392             t << "default: debug-winscw";
393         else if (debugPlatforms.size())
394             t << "default: debug-" << debugPlatforms.first();
395         else
396             t << "default: all";
397         t << endl;
398
399         QString qmakeCmd = "\t$(QMAKE) \"" + project->projectFile() + "\" " + buildArgs();
400
401         t << "qmake:" << endl;
402         t << qmakeCmd << endl;
403         t << endl;
404
405         t << BLD_INF_FILENAME ": " << project->projectFile() << endl;
406         t << qmakeCmd << endl;
407         t << endl;
408
409         QString locFileDep = generateLocFileTarget(t, qmakeCmd);
410
411         t << "debug: " << locFileDep << BLD_INF_FILENAME << endl;
412         t << "\t$(SBS)";
413         foreach(QString clause, debugClauses) {
414             t << clause;
415         }
416         t << endl;
417         t << "clean-debug: " << BLD_INF_FILENAME << endl;
418         t << "\t$(SBS) reallyclean --toolcheck=off";
419         foreach(QString clause, debugClauses) {
420             t << clause;
421         }
422         t << endl;
423
424         t << "freeze-debug: " << BLD_INF_FILENAME << endl;
425         t << "\t$(SBS) freeze";
426         foreach(QString clause, debugClauses) {
427             t << clause;
428         }
429         t << endl;
430
431         t << "release: " << locFileDep << BLD_INF_FILENAME << endl;
432         t << "\t$(SBS)";
433         foreach(QString clause, releaseClauses) {
434             t << clause;
435         }
436         t << endl;
437         t << "clean-release: " << BLD_INF_FILENAME << endl;
438         t << "\t$(SBS) reallyclean --toolcheck=off";
439         foreach(QString clause, releaseClauses) {
440             t << clause;
441         }
442         t << endl;
443
444         t << "freeze-release: " << BLD_INF_FILENAME << endl;
445         t << "\t$(SBS) freeze";
446         foreach(QString clause, releaseClauses) {
447             t << clause;
448         }
449         t << endl << endl;
450
451         QString defaultGcceArmVersion;
452         if (armPlatforms.size()) {
453             defaultGcceArmVersion = armPlatforms.first();
454         } else {
455             defaultGcceArmVersion = QLatin1String("armv5");
456         }
457
458         // For more specific builds, targets are in this form:
459         // release-armv5 - generic target, compiler version determined by toolchain or autodetection
460         // release-armv5-rvct4.0 - compiler version specific target
461         foreach(QString item, debugPlatforms) {
462             QString clause;
463             if (item.compare(winscwPlatform) == 0)
464                 clause = configClause(item, debugBuild, QString(), winscwClause);
465             else if (item.compare(gccePlatform) == 0 )
466                 clause = configClause(defaultGcceArmVersion, debugBuild, defaultGcceCompilerVersion, armClause);
467             else // use generic arm clause
468                 clause = configClause(item, debugBuild, defaultRvctCompilerVersion, genericArmClause);
469
470             t << "debug-" << item << ": " << locFileDep << BLD_INF_FILENAME << endl;
471             t << "\t$(SBS)" << clause << endl;
472             t << "clean-debug-" << item << ": " << BLD_INF_FILENAME << endl;
473             t << "\t$(SBS) reallyclean" << clause << endl;
474             t << "freeze-debug-" << item << ": " << BLD_INF_FILENAME << endl;
475             t << "\t$(SBS) freeze" << clause << endl;
476         }
477
478         foreach(QString item, releasePlatforms) {
479             QString clause;
480             if (item.compare(gccePlatform) == 0 )
481                 clause = configClause(defaultGcceArmVersion, releaseBuild, defaultGcceCompilerVersion, armClause);
482             else // use generic arm clause
483                 clause = configClause(item, releaseBuild, defaultRvctCompilerVersion, genericArmClause);
484
485             t << "release-" << item << ": " << locFileDep << BLD_INF_FILENAME << endl;
486             t << "\t$(SBS)" << clause << endl;
487             t << "clean-release-" << item << ": " << BLD_INF_FILENAME << endl;
488             t << "\t$(SBS) reallyclean" << clause << endl;
489             t << "freeze-release-" << item << ": " << BLD_INF_FILENAME << endl;
490             t << "\t$(SBS) freeze" << clause << endl;
491         }
492
493         foreach(QString item, armPlatforms) {
494             foreach(QString compilerVersion, allArmCompilerVersions) {
495                 QString debugClause = configClause(item, debugBuild, compilerVersion, armClause);
496                 QString releaseClause = configClause(item, releaseBuild, compilerVersion, armClause);
497                 t << "debug-" << item << "-" << compilerVersion << ": " << locFileDep << BLD_INF_FILENAME << endl;
498                 t << "\t$(SBS)" << debugClause << endl;
499                 t << "clean-debug-" << item << "-" << compilerVersion << ": " << BLD_INF_FILENAME << endl;
500                 t << "\t$(SBS) reallyclean" << debugClause << endl;
501                 t << "freeze-debug-" << item << "-" << compilerVersion << ": " << BLD_INF_FILENAME << endl;
502                 t << "\t$(SBS) freeze" << debugClause << endl;
503                 t << "release-" << item << "-" << compilerVersion << ": " << locFileDep << BLD_INF_FILENAME << endl;
504                 t << "\t$(SBS)" << releaseClause << endl;
505                 t << "clean-release-" << item << "-" << compilerVersion << ": " << BLD_INF_FILENAME << endl;
506                 t << "\t$(SBS) reallyclean" << releaseClause << endl;
507                 t << "freeze-release-" << item << "-" << compilerVersion << ": " << BLD_INF_FILENAME << endl;
508                 t << "\t$(SBS) freeze" << releaseClause << endl;
509             }
510         }
511
512         t << endl;
513         t << "export: " << BLD_INF_FILENAME << endl;
514         t << "\t$(SBS) export";
515         foreach(QString clause, allClauses) {
516             t << clause;
517         }
518         t << endl << endl;
519
520         t << "cleanexport: " << BLD_INF_FILENAME << endl;
521         t << "\t$(SBS) cleanexport";
522         foreach(QString clause, allClauses) {
523             t << clause;
524         }
525         t << endl << endl;
526
527         // Typically one wants to freeze release binaries, so make plain freeze target equal to
528         // freeze-release. If freezing of debug binaries is needed for some reason, then
529         // freeze-debug target should be used. There is no point to try freezing both with one
530         // target as both produce the same def file.
531         t << "freeze: freeze-release" << endl << endl;
532     }
533
534     // Add all extra targets including extra compiler targets also to wrapper makefile,
535     // even though many of them may have already been added to bld.inf as FLMs.
536     // This is to enable use of targets like 'mocables', which call targets generated by extra compilers.
537     if (targetType != TypeSubdirs) {
538         t << extraTargetsCache;
539         t << extraCompilersCache;
540     } else {
541         QList<MakefileGenerator::SubTarget*> subtargets = findSubDirsSubTargets();
542         writeSubTargets(t, subtargets, SubTargetSkipDefaultVariables|SubTargetSkipDefaultTargets);
543         qDeleteAll(subtargets);
544     }
545
546     generateDistcleanTargets(t);
547
548     // Do not check for tools when doing generic clean, as most tools are not actually needed for
549     // cleaning. Mainly this is relevant for environments that do not have winscw compiler.
550     t << "clean: " << BLD_INF_FILENAME << endl;
551     t << "\t-$(SBS) reallyclean --toolcheck=off";
552     foreach(QString clause, allClauses) {
553         t << clause;
554     }
555     t << endl << endl;
556
557     t << endl;
558 }
559
560 void SymbianSbsv2MakefileGenerator::writeBldInfExtensionRulesPart(QTextStream& t, const QString &iconTargetFile)
561 {
562     // Makes sure we have needed FLMs in place.
563     exportFlm();
564
565     // Parse extra compilers data
566     QStringList defines;
567     QStringList incPath;
568
569     defines << varGlue("PRL_EXPORT_DEFINES","-D"," -D"," ")
570             << varGlue("QMAKE_COMPILER_DEFINES", "-D", "-D", " ")
571             << varGlue("DEFINES","-D"," -D","");
572     for (QMap<QString, QStringList>::iterator it = systeminclude.begin(); it != systeminclude.end(); ++it) {
573         QStringList values = it.value();
574         for (int i = 0; i < values.size(); ++i) {
575             incPath << QLatin1String(" -I\"") + values.at(i) + "\"";
576         }
577     }
578
579     QMap<QString, QString> commandsToReplace;
580     commandsToReplace.insert(project->values("QMAKE_COPY").join(" "),
581                              project->values("QMAKE_SBSV2_COPY").join(" "));
582     commandsToReplace.insert(project->values("QMAKE_COPY_DIR").join(" "),
583                              project->values("QMAKE_SBSV2_COPY_DIR").join(" "));
584     commandsToReplace.insert(project->values("QMAKE_MOVE").join(" "),
585                              project->values("QMAKE_SBSV2_MOVE").join(" "));
586     commandsToReplace.insert(project->values("QMAKE_DEL_FILE").join(" "),
587                              project->values("QMAKE_SBSV2_DEL_FILE").join(" "));
588     commandsToReplace.insert(project->values("QMAKE_MKDIR").join(" "),
589                              project->values("QMAKE_SBSV2_MKDIR").join(" "));
590     commandsToReplace.insert(project->values("QMAKE_DEL_DIR").join(" "),
591                              project->values("QMAKE_SBSV2_DEL_DIR").join(" "));
592     commandsToReplace.insert(project->values("QMAKE_DEL_TREE").join(" "),
593                              project->values("QMAKE_SBSV2_DEL_TREE").join(" "));
594
595     // Write extra compilers and targets to initialize QMAKE_ET_* variables
596     // Cache results to avoid duplicate calls when creating wrapper makefile
597     QTextStream extraCompilerStream(&extraCompilersCache);
598     QTextStream extraTargetStream(&extraTargetsCache);
599     writeExtraCompilerTargets(extraCompilerStream);
600     writeExtraTargets(extraTargetStream);
601
602     // Figure out everything the target depends on as we don't want to run extra targets that
603     // are not necessary.
604     QStringList allPreDeps;
605     foreach(QString item, project->values("PRE_TARGETDEPS")) {
606         allPreDeps.append(fileInfo(item).absoluteFilePath());
607     }
608
609     foreach (QString item, project->values("GENERATED_SOURCES")) {
610         allPreDeps.append(fileInfo(item).absoluteFilePath());
611     }
612
613     for (QMap<QString, QStringList>::iterator it = sources.begin(); it != sources.end(); ++it) {
614         QString currentSourcePath = it.key();
615         QStringList values = it.value();
616         for (int i = 0; i < values.size(); ++i) {
617             QString sourceFile = currentSourcePath + "/" + values.at(i);
618             QStringList deps = findDependencies(QDir::toNativeSeparators(sourceFile));
619             foreach(QString depItem, deps) {
620                 appendIfnotExist(allPreDeps, fileInfo(depItem).absoluteFilePath());
621             }
622         }
623     }
624
625     // Write FLM rules for all extra targets and compilers that we depend on to build the target.
626     QStringList extraTargets;
627     extraTargets << project->values("QMAKE_EXTRA_TARGETS") <<  project->values("QMAKE_EXTRA_COMPILERS");
628     foreach(QString item, extraTargets) {
629         foreach(QString targetItem, project->values(QLatin1String("QMAKE_INTERNAL_ET_PARSED_TARGETS.") + item)) {
630             // Make sure targetpath is absolute
631             QString absoluteTarget = fileInfo(targetItem).absoluteFilePath();
632             if (allPreDeps.contains(absoluteTarget)) {
633                 QStringList deps = project->values(QLatin1String("QMAKE_INTERNAL_ET_PARSED_DEPS.") + item + targetItem);
634                 QString commandItem =  project->values(QLatin1String("QMAKE_INTERNAL_ET_PARSED_CMD.") + item + targetItem).join(" ");
635
636                 // Make sure all deps paths are absolute
637                 QString absoluteDeps;
638                 foreach (QString depItem, deps) {
639                     if (!depItem.isEmpty()) {
640                         absoluteDeps.append(fileInfo(depItem).absoluteFilePath());
641                         absoluteDeps.append(" ");
642                     }
643                 }
644
645                 t << "START EXTENSION qt/qmake_extra_pre_targetdep.export" << endl;
646                 t << "OPTION PREDEP_TARGET " << absoluteTarget << endl;
647                 t << "OPTION DEPS " << absoluteDeps << endl;
648
649                 if (commandItem.indexOf("$(INCPATH)") != -1)
650                     commandItem.replace("$(INCPATH)", incPath.join(" "));
651                 if (commandItem.indexOf("$(DEFINES)") != -1)
652                     commandItem.replace("$(DEFINES)", defines.join(" "));
653
654                 fixFlmCmd(&commandItem, commandsToReplace);
655
656                 t << "OPTION COMMAND " << commandItem << endl;
657                 t << "END" << endl;
658             }
659         }
660     }
661
662     t << endl;
663
664     // Write deployment rules
665     QString remoteTestPath = qt_epocRoot() + QLatin1String("epoc32/winscw/c/private/") + privateDirUid;
666     DeploymentList depList;
667
668     //write emulator deployment
669     t << "#if defined(WINSCW)" << endl;
670     initProjectDeploySymbian(project, depList, remoteTestPath, false, true,
671         QLatin1String(EMULATOR_DEPLOYMENT_PLATFORM), QString(), generatedDirs, generatedFiles);
672     writeSbsDeploymentList(depList, t);
673     t << "#endif" << endl;
674
675     //write ROM deployment
676     remoteTestPath = qt_epocRoot() + QLatin1String("epoc32/data/z/private/") + privateDirUid;
677     depList.clear();
678     initProjectDeploySymbian(project, depList, remoteTestPath, false, true,
679         QLatin1String(ROM_DEPLOYMENT_PLATFORM), QString(), generatedDirs, generatedFiles);
680     writeSbsDeploymentList(depList, t);
681     t << endl;
682
683     // Write post link rules
684     if (!project->isEmpty("QMAKE_POST_LINK")) {
685         QString postLinkCmd = var("QMAKE_POST_LINK");
686         fixFlmCmd(&postLinkCmd, commandsToReplace);
687         t << "START EXTENSION qt/qmake_post_link" << endl;
688         t << "OPTION POST_LINK_CMD " << postLinkCmd << endl;
689         t << "OPTION LINK_TARGET " << fixedTarget << QLatin1String(".") << getTargetExtension() << endl;
690         t << "END" << endl;
691         t << endl;
692     }
693
694     // Application icon generation
695     QStringList icons = project->values("ICON");
696     if (icons.size()) {
697         QString icon = icons.first();
698         if (icons.size() > 1)
699             fprintf(stderr, "Warning: Only first icon specified in ICON variable is used: '%s'.", qPrintable(icon));
700
701         t << "START EXTENSION s60/mifconv" << endl;
702
703         QFileInfo iconInfo = fileInfo(icon);
704
705         QFileInfo bldinf(project->values("MAKEFILE").first());
706         QString iconPath = bldinf.dir().relativeFilePath(iconInfo.path());
707
708         QString iconFile = iconInfo.baseName();
709
710         QFileInfo iconTargetInfo = fileInfo(iconTargetFile);
711         QString iconTarget = iconTargetInfo.fileName();
712
713         t << "OPTION SOURCES -c32 " << iconFile << endl;
714         t << "OPTION SOURCEDIR " << iconPath << endl;
715         t << "OPTION TARGETFILE " << iconTarget << endl;
716         t << "OPTION SVGENCODINGVERSION 3" << endl; // Compatibility with S60 3.1 devices and up
717         t << "END" << endl;
718     }
719
720     t << "START EXTENSION qt/qmake_store_build" << endl;
721     t << "END" << endl;
722     t << endl;
723
724     t << endl;
725 }
726
727 void SymbianSbsv2MakefileGenerator::writeBldInfMkFilePart(QTextStream& t, bool addDeploymentExtension)
728 {
729     // We don't generate extension makefile in sbsb2
730     Q_UNUSED(t);
731     Q_UNUSED(addDeploymentExtension);
732 }
733
734 void SymbianSbsv2MakefileGenerator::appendAbldTempDirs(QStringList& sysincspaths, QString includepath)
735 {
736     //Do nothing
737     Q_UNUSED(sysincspaths);
738     Q_UNUSED(includepath);
739 }