← Back to branch summary

~bzoltan/kubuntu-packaging/decouple_cmake_plugin

« back to all changes in this revision

Viewing changes to src/plugins/android/androidtoolchain.cpp

  • Committer: Timo Jyrinki
  • Date: 2013-11-15 12:25:23 UTC
  • mfrom: (1.1.28)
  • Revision ID: timo.jyrinki@canonical.com-20131115122523-i2kyamsu4gs2mu1m
New upstream release.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/plugins/android/androidtoolchain.cpp
32
32
#include "androidconfigurations.h"
33
33
#include "androidqtversion.h"
34
34
 
 
35
#include <extensionsystem/pluginmanager.h>
 
36
 
35
37
#include <qtsupport/qtkitinformation.h>
36
38
#include <qtsupport/qtversionmanager.h>
37
39
 
61
63
static const char ANDROID_QT_VERSION_KEY[] = "Qt4ProjectManager.Android.QtVersion";
62
64
static const char ANDROID_NDK_TC_VERION[] = "Qt4ProjectManager.Android.NDK_TC_VERION";
63
65
 
64
 
AndroidToolChain::AndroidToolChain(Abi::Architecture arch, const QString &ndkToolChainVersion, bool autodetected)
65
 
    : GccToolChain(QLatin1String(Constants::ANDROID_TOOLCHAIN_ID), autodetected),
66
 
      m_ndkToolChainVersion(ndkToolChainVersion)
 
66
QMap<ProjectExplorer::Abi::Architecture, QList<int> > AndroidToolChainFactory::m_newestVersionForArch;
 
67
Utils::FileName AndroidToolChainFactory::m_ndkLocation;
 
68
 
 
69
AndroidToolChain::AndroidToolChain(Abi::Architecture arch, const QString &ndkToolChainVersion, Detection d)
 
70
    : GccToolChain(QLatin1String(Constants::ANDROID_TOOLCHAIN_ID), d),
 
71
      m_ndkToolChainVersion(ndkToolChainVersion), m_secondaryToolChain(false)
67
72
{
68
73
    ProjectExplorer::Abi abi = ProjectExplorer::Abi(arch, ProjectExplorer::Abi::LinuxOS,
69
74
                                                    ProjectExplorer::Abi::AndroidLinuxFlavor, ProjectExplorer::Abi::ElfFormat,
76
81
 
77
82
// for fromMap
78
83
AndroidToolChain::AndroidToolChain()
79
 
    : GccToolChain(QLatin1String(Constants::ANDROID_TOOLCHAIN_ID), false)
 
84
    : GccToolChain(QLatin1String(Constants::ANDROID_TOOLCHAIN_ID), ToolChain::ManualDetection),
 
85
      m_secondaryToolChain(false)
80
86
{
81
87
}
82
88
 
83
89
AndroidToolChain::AndroidToolChain(const AndroidToolChain &tc) :
84
 
    GccToolChain(tc), m_ndkToolChainVersion(tc.m_ndkToolChainVersion)
 
90
    GccToolChain(tc), m_ndkToolChainVersion(tc.m_ndkToolChainVersion),
 
91
    m_secondaryToolChain(tc.m_secondaryToolChain)
85
92
{ }
86
93
 
87
94
AndroidToolChain::~AndroidToolChain()
89
96
 
90
97
QString AndroidToolChain::type() const
91
98
{
92
 
    return QLatin1String(Android::Constants::ANDROID_TOOLCHAIN_TYPE);
 
99
    return QLatin1String(Constants::ANDROID_TOOLCHAIN_TYPE);
93
100
}
94
101
 
95
102
QString AndroidToolChain::typeDisplayName() const
117
124
    if (!javaHome.isEmpty() && QFileInfo(javaHome).exists())
118
125
        env.set(QLatin1String("JAVA_HOME"), javaHome);
119
126
    env.set(QLatin1String("ANDROID_HOME"), AndroidConfigurations::instance().config().sdkLocation.toString());
 
127
    env.set(QLatin1String("ANDROID_SDK_ROOT"), AndroidConfigurations::instance().config().sdkLocation.toString());
120
128
}
121
129
 
122
130
bool AndroidToolChain::operator ==(const ToolChain &tc) const
194
202
        m_ndkToolChainVersion = data.value(QLatin1String(ANDROID_NDK_TC_VERION)).toString();
195
203
    }
196
204
 
 
205
    ProjectExplorer::Abi::Architecture arch = targetAbi().architecture();
 
206
    m_secondaryToolChain = AndroidToolChainFactory::versionCompareLess(AndroidToolChainFactory::versionNumberFromString(m_ndkToolChainVersion),
 
207
                                                                       AndroidToolChainFactory::newestToolChainVersionForArch(arch));
197
208
    return isValid();
198
209
}
199
210
 
218
229
    return tmp.isEmpty() ? make : tmp;
219
230
}
220
231
 
221
 
QString AndroidToolChain::ndkToolChainVersion()
 
232
QString AndroidToolChain::ndkToolChainVersion() const
222
233
{
223
234
    return m_ndkToolChainVersion;
224
235
}
225
236
 
 
237
bool AndroidToolChain::isSecondaryToolChain() const
 
238
{
 
239
    return m_secondaryToolChain;
 
240
}
 
241
 
 
242
void AndroidToolChain::setSecondaryToolChain(bool b)
 
243
{
 
244
    m_secondaryToolChain = b;
 
245
}
 
246
 
226
247
QList<Abi> AndroidToolChain::detectSupportedAbis() const
227
248
{
228
249
    return QList<Abi>() << targetAbi();
243
264
// ToolChainFactory
244
265
// --------------------------------------------------------------------------
245
266
 
246
 
AndroidToolChainFactory::AndroidToolChainFactory() :
247
 
    ToolChainFactory()
248
 
{ }
249
 
 
250
 
QString AndroidToolChainFactory::displayName() const
251
 
{
252
 
    return tr("Android GCC");
253
 
}
254
 
 
255
 
QString AndroidToolChainFactory::id() const
256
 
{
257
 
    return QLatin1String(Constants::ANDROID_TOOLCHAIN_ID);
 
267
AndroidToolChainFactory::AndroidToolChainFactory()
 
268
{
 
269
    setId(Constants::ANDROID_TOOLCHAIN_ID);
 
270
    setDisplayName(tr("Android GCC"));
258
271
}
259
272
 
260
273
QList<ToolChain *> AndroidToolChainFactory::autoDetect()
305
318
    return result;
306
319
}
307
320
 
 
321
QList<int> AndroidToolChainFactory::versionNumberFromString(const QString &version)
 
322
{
 
323
    QList<int> result;
 
324
    int start = 0;
 
325
    int end = version.length();
 
326
    while (start <= end) {
 
327
        int index = version.indexOf(QLatin1Char('.'), start);
 
328
        if (index == -1)
 
329
            index = end;
 
330
 
 
331
        bool ok;
 
332
        int v = version.mid(start, index - start).toInt(&ok);
 
333
        if (!ok) // unparseable, return what we have
 
334
            return result;
 
335
 
 
336
        result << v;
 
337
        start = index + 1;
 
338
    }
 
339
    return result;
 
340
}
 
341
 
 
342
bool AndroidToolChainFactory::versionCompareLess(const QList<int> &a, const QList<int> &b)
 
343
{
 
344
    int aend = a.length();
 
345
    int bend = b.length();
 
346
    int end = qMax(aend, bend);
 
347
    for (int i = 0; i < end; ++i) {
 
348
        int an = i < aend ? a.at(i) : 0;
 
349
        int bn = i < bend ? b.at(i) : 0;
 
350
        if (an < bn)
 
351
            return true;
 
352
        if (bn < an)
 
353
            return false;
 
354
    }
 
355
    return false;
 
356
}
 
357
 
 
358
bool AndroidToolChainFactory::versionCompareLess(AndroidToolChain *atc, AndroidToolChain *btc)
 
359
{
 
360
    QList<int> a = versionNumberFromString(atc->ndkToolChainVersion());
 
361
    QList<int> b = versionNumberFromString(btc->ndkToolChainVersion());
 
362
 
 
363
    return versionCompareLess(a, b);
 
364
}
 
365
 
308
366
QList<ToolChain *> AndroidToolChainFactory::createToolChainsForNdk(const Utils::FileName &ndkPath)
309
367
{
310
368
    QList<ToolChain *> result;
314
372
    FileName path = ndkPath;
315
373
    QDirIterator it(path.appendPath(QLatin1String("toolchains")).toString(),
316
374
                    QStringList() << QLatin1String("*"), QDir::Dirs);
 
375
    QMap<Abi::Architecture, AndroidToolChain *> newestToolChainForArch;
 
376
 
317
377
    while (it.hasNext()) {
318
378
        const QString &fileName = QFileInfo(it.next()).fileName();
319
379
        int idx = versionRegExp.indexIn(fileName);
324
384
        Abi::Architecture arch = AndroidConfigurations::architectureForToolChainPrefix(platform);
325
385
        if (arch == Abi::UnknownArchitecture) // e.g. mipsel which is not yet supported
326
386
            continue;
327
 
        AndroidToolChain *tc = new AndroidToolChain(arch, version, true);
 
387
        AndroidToolChain *tc = new AndroidToolChain(arch, version, ToolChain::AutoDetection);
328
388
        FileName compilerPath = AndroidConfigurations::instance().gccPath(arch, version);
329
389
        tc->setCompilerCommand(compilerPath);
330
390
        result.append(tc);
331
 
    }
 
391
 
 
392
        QMap<Abi::Architecture, AndroidToolChain *>::const_iterator it
 
393
                = newestToolChainForArch.constFind(arch);
 
394
        if (it == newestToolChainForArch.constEnd())
 
395
            newestToolChainForArch.insert(arch, tc);
 
396
        else if (versionCompareLess(it.value(), tc))
 
397
            newestToolChainForArch[arch] = tc;
 
398
    }
 
399
 
 
400
    foreach (ToolChain *tc, result) {
 
401
        AndroidToolChain *atc = static_cast<AndroidToolChain *>(tc);
 
402
        if (newestToolChainForArch.value(atc->targetAbi().architecture()) != atc)
 
403
            atc->setSecondaryToolChain(true);
 
404
    }
 
405
 
332
406
    return result;
333
407
}
334
408
 
 
409
QList<int> AndroidToolChainFactory::newestToolChainVersionForArch(Abi::Architecture arch)
 
410
{
 
411
    if (m_newestVersionForArch.isEmpty()
 
412
            || m_ndkLocation != AndroidConfigurations::instance().config().ndkLocation) {
 
413
        QRegExp versionRegExp(NDKGccVersionRegExp);
 
414
        m_ndkLocation = AndroidConfigurations::instance().config().ndkLocation;
 
415
        FileName path = m_ndkLocation;
 
416
        QDirIterator it(path.appendPath(QLatin1String("toolchains")).toString(),
 
417
                        QStringList() << QLatin1String("*"), QDir::Dirs);
 
418
        while (it.hasNext()) {
 
419
            const QString &fileName = QFileInfo(it.next()).fileName();
 
420
            int idx = versionRegExp.indexIn(fileName);
 
421
            if (idx == -1)
 
422
                continue;
 
423
            QList<int> version = versionNumberFromString(fileName.mid(idx + 1));
 
424
            QString platform = fileName.left(idx);
 
425
            Abi::Architecture arch = AndroidConfigurations::architectureForToolChainPrefix(platform);
 
426
            if (arch == Abi::UnknownArchitecture) // e.g. mipsel which is not yet supported
 
427
                continue;
 
428
            QMap<Abi::Architecture, QList<int> >::const_iterator it
 
429
                    = m_newestVersionForArch.constFind(arch);
 
430
            if (it == m_newestVersionForArch.constEnd())
 
431
                m_newestVersionForArch.insert(arch, version);
 
432
            else if (versionCompareLess(it.value(), version))
 
433
                m_newestVersionForArch[arch] = version;
 
434
        }
 
435
    }
 
436
    return m_newestVersionForArch.value(arch);
 
437
}
 
438
 
335
439
} // namespace Internal
336
440
} // namespace Android