qtcreator-tizen-plugin/tizentoolchain.cpp

/****************************************************************************
**
** Copyright (C) 2013 Jarek Pelczar <jpelczar@gmail.com>
**
** This file is part of Qt Creator.
**
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and Digia.  For licensing terms and
** conditions see http://qt.digia.com/licensing.  For further information
** use the contact form at http://qt.digia.com/contact-us.
**
** 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, Digia gives you certain additional
** rights.  These rights are described in the Digia Qt LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
****************************************************************************/

#include "tizentoolchain.h"
#include "tizenconstants.h"
#include "tizenconfigurations.h"

#include <QDirIterator>
#include <QProcess>

#include <utils/hostosinfo.h>

using namespace ProjectExplorer;

namespace Tizen {

namespace {
    const QLatin1String tizen_emulator_mkspec("devices/linux-g++-tizen-emulator");
    const QLatin1String tizen_mobile_mkspec("devices/linux-g++-tizen-mobile");
    const QLatin1String tizen_ivi_mkspec("devices/linux-g++-tizen-ivi");
}

TizenGccToolchain::~TizenGccToolchain()
{
}

QString TizenGccToolchain::type() const
{
    return QLatin1String(Constants::TIZEN_TOOLCHAIN_GCC_TYPE);
}

QString TizenGccToolchain::typeDisplayName() const
{
    return TizenToolchainFactory::tr("Tizen GCC");
}

bool TizenGccToolchain::isValid() const
{
    return GccToolChain::isValid() &&
            targetAbi().isValid();
}

void TizenGccToolchain::addToEnvironment(Utils::Environment &env) const
{
    GccToolChain::addToEnvironment(env);
}

bool TizenGccToolchain::operator ==(const ProjectExplorer::ToolChain & other) const
{
    if(!GccToolChain::operator ==(other))
        return false;
    return true;
}

ProjectExplorer::ToolChainConfigWidget * TizenGccToolchain::configurationWidget()
{
    return GccToolChain::configurationWidget();
}

Utils::FileName TizenGccToolchain::suggestedDebugger() const
{
    return GccToolChain::suggestedDebugger();
}

QVariantMap TizenGccToolchain::toMap() const
{
    QVariantMap vm = GccToolChain::toMap();
    return vm;
}

bool TizenGccToolchain::fromMap(const QVariantMap &data)
{
    if(!GccToolChain::fromMap(data))
        return false;
    return isValid();
}

QString TizenGccToolchain::makeCommand(const Utils::Environment &environment) const
{
    return GccToolChain::makeCommand(environment);
}

QList<Utils::FileName> TizenGccToolchain::suggestedMkspecList() const
{
    return QList<Utils::FileName>() << Utils::FileName::fromString(tizen_emulator_mkspec)
                                    << Utils::FileName::fromString(tizen_mobile_mkspec)
                                    << Utils::FileName::fromString(tizen_ivi_mkspec);
}

QList<Abi> TizenGccToolchain::detectSupportedAbis() const
{
    return QList<Abi>() << targetAbi();
}

TizenGccToolchain::TizenGccToolchain() :
    GccToolChain(QLatin1String(Constants::TIZEN_TOOLCHAIN_ID), false)
{
}

TizenGccToolchain::TizenGccToolchain(const ProjectExplorer::Abi::Architecture arch, bool autoDetected) :
    GccToolChain(QLatin1String(Constants::TIZEN_TOOLCHAIN_ID), autoDetected)
{
    ProjectExplorer::Abi abi = ProjectExplorer::Abi(arch,
                                                    ProjectExplorer::Abi::LinuxOS,
                                                    ProjectExplorer::Abi::GenericLinuxFlavor,
                                                    ProjectExplorer::Abi::ElfFormat,
                                                    32);

    setTargetAbi(abi);
    setDisplayName(QString::fromLatin1("Tizen GCC (%1)")
                   .arg(Abi::toString(abi.architecture())));
}

TizenGccToolchain::TizenGccToolchain(const TizenGccToolchain& other) :
    GccToolChain(other)
{
}

TizenToolchainFactory::TizenToolchainFactory()
{

}

QString TizenToolchainFactory::displayName() const
{
    return tr("Tizen GCC");
}

QString TizenToolchainFactory::id() const
{
    return QLatin1String(Constants::TIZEN_TOOLCHAIN_ID);
}


QList<ProjectExplorer::ToolChain *> TizenToolchainFactory::autoDetect()
{
    return createToolchainsForSdk(TizenConfigurations::instance()->tizenConfig().m_sdkLocation.toString(),
                                  TizenConfigurations::instance()->tizenConfig().m_sbiLocation.toString());
}

bool TizenToolchainFactory::canRestore(const QVariantMap &data)
{
    return idFromMap(data).startsWith(QLatin1String(Constants::TIZEN_TOOLCHAIN_ID) + QLatin1Char(':'));
}

ToolChain *TizenToolchainFactory::restore(const QVariantMap &data)
{
    TizenGccToolchain * tc = new TizenGccToolchain();
    if(tc->fromMap(data))
        return tc;
    delete tc;
    return NULL;
}

static QList<Abi> guessGccAbi(const QString &m)
{
    QList<Abi> abiList;

    QString machine = m.toLower();
    if (machine.isEmpty())
        return abiList;

    QStringList parts = machine.split(QRegExp(QLatin1String("[ /-]")));

    Abi::Architecture arch = Abi::UnknownArchitecture;
    Abi::OS os = Abi::UnknownOS;
    Abi::OSFlavor flavor = Abi::UnknownFlavor;
    Abi::BinaryFormat format = Abi::UnknownFormat;
    int width = 0;
    int unknownCount = 0;

    foreach (const QString &p, parts) {
        if (p == QLatin1String("unknown") || p == QLatin1String("pc") || p == QLatin1String("none")
                || p == QLatin1String("gnu") || p == QLatin1String("uclibc")
                || p == QLatin1String("86_64") || p == QLatin1String("redhat")
                || p == QLatin1String("gnueabi") || p == QLatin1String("w64")) {
            continue;
        } else if (p == QLatin1String("i386") || p == QLatin1String("i486") || p == QLatin1String("i586")
                   || p == QLatin1String("i686") || p == QLatin1String("x86")) {
            arch = Abi::X86Architecture;
        } else if (p.startsWith(QLatin1String("arm"))) {
            arch = Abi::ArmArchitecture;
            width = 32;
        } else if (p == QLatin1String("mipsel")) {
            arch = Abi::MipsArchitecture;
            width = 32;
        } else if (p == QLatin1String("x86_64") || p == QLatin1String("amd64")) {
            arch = Abi::X86Architecture;
            width = 64;
        } else if (p == QLatin1String("powerpc64")) {
            arch = Abi::PowerPCArchitecture;
            width = 64;
        } else if (p == QLatin1String("powerpc")) {
            arch = Abi::PowerPCArchitecture;
            width = 32;
        } else if (p == QLatin1String("linux") || p == QLatin1String("linux6e")) {
            os = Abi::LinuxOS;
            if (flavor == Abi::UnknownFlavor)
                flavor = Abi::GenericLinuxFlavor;
            format = Abi::ElfFormat;
        } else if (p.startsWith(QLatin1String("freebsd"))) {
            os = Abi::BsdOS;
            if (flavor == Abi::UnknownFlavor)
                flavor = Abi::FreeBsdFlavor;
            format = Abi::ElfFormat;
        } else if (p == QLatin1String("mingw32") || p == QLatin1String("win32") || p == QLatin1String("mingw32msvc")) {
            arch = Abi::X86Architecture;
            os = Abi::WindowsOS;
            flavor = Abi::WindowsMSysFlavor;
            format = Abi::PEFormat;
        } else if (p == QLatin1String("apple")) {
            os = Abi::MacOS;
            flavor = Abi::GenericMacFlavor;
            format = Abi::MachOFormat;
        } else if (p == QLatin1String("darwin10")) {
            width = 64;
        } else if (p == QLatin1String("darwin9")) {
            width = 32;
        } else if (p == QLatin1String("gnueabi")) {
            format = Abi::ElfFormat;
        } else {
            ++unknownCount;
        }
    }

    if (unknownCount == parts.count())
        return abiList;

    if (os == Abi::MacOS && arch != Abi::ArmArchitecture) {
        // Apple does PPC and x86!
        abiList << Abi(arch, os, flavor, format, width);
        abiList << Abi(arch, os, flavor, format, width == 64 ? 32 : 64);
        abiList << Abi(arch == Abi::X86Architecture ? Abi::PowerPCArchitecture : Abi::X86Architecture, os, flavor, format, width);
        abiList << Abi(arch == Abi::X86Architecture ? Abi::PowerPCArchitecture : Abi::X86Architecture, os, flavor, format, width == 64 ? 32 : 64);
    } else if (arch == Abi::X86Architecture && (width == 0 || width == 64)) {
//        if (macros.contains("#define __x86_64 1"))
//            abiList << Abi(arch, os, flavor, format, 64);
        abiList << Abi(arch, os, flavor, format, 32);
    } else {
        abiList << Abi(arch, os, flavor, format, width);
    }
    return abiList;
}

QList<ProjectExplorer::ToolChain *> TizenToolchainFactory::createToolchainsForSdk(const QString& sdkPath, const QString &sbiPath)
{
    Q_UNUSED(sbiPath)

    QList<ProjectExplorer::ToolChain *> result;
    if(sdkPath.isEmpty())
        return result;

    Utils::FileName path = Utils::FileName::fromString(sdkPath);

    QDirIterator it(path.appendPath(QLatin1String("tools")).toString(),
                    QStringList() << QLatin1String("*gcc*"),
                    QDir::Dirs);

    const QLatin1String bin_dir("bin");

    while(it.hasNext()) {
        const QString dirName = QFileInfo(it.next()).fileName();
        Utils::FileName gccPath = Utils::FileName::fromString(it.filePath()).appendPath(bin_dir);

        QDirIterator gcc_paths(gccPath.toString(),
                               QStringList() << QLatin1String("*gcc"),
                               QDir::Files|QDir::Executable);
        if(gcc_paths.hasNext()) {
            gcc_paths.next();
            QString fullGccPath = gcc_paths.filePath();
            QList<Abi> abis = guessGccAbi(dirName);
            if(!abis.empty()) {
                TizenGccToolchain * tc = new TizenGccToolchain(abis[0].architecture(),
                                                               true);
                tc->setCompilerCommand(Utils::FileName::fromString(fullGccPath));
                result.append(tc);
            }
        }
    }

    return result;
}

bool TizenToolchainFactory::canCreate()
{
    return false;
}

ProjectExplorer::ToolChain * TizenToolchainFactory::create()
{
    return new TizenGccToolchain();
}

} // namespace Tizen